package mandreelFile1;

import Class.MandreelElement.MandreelBase;
import Class.MandreelElement.MandreelElement;

import java.util.ArrayList;
import java.util.List;

import static Class.CommonClassFile.commonVariable;
import static Class.CommonClassFile.heapClassInst;
import static Class.DevNumber.*;
import static Class.MandreelDocument.mandreelDocument;
import static commonFile.CommonFile.*;
import static commonFile.SwriteIndex.swriteIndex;
import static mandreelFile2.mandreelFile2.zn28btHashedOverlappingPairCacheC1Ev;
import static mandreelFile4.mandreelFile4.*;
import static mandreelFile5.mandreelFile5.zn19btTriangleMeshShape15recalcLocalAabbEv;
import static mandreelFile8.mandreelFile8.*;


public class mandreelFile1 {
    public static WebkitAudioContext webAudioContext = new WebkitAudioContext();
    public static boolean webAudioUseMusicFunctions = true;
    public static String[] webAudioBuffers = new String[0];
    public static int[] webAudioChannels = new int[numDefine32];
    public static int[] webAudioGain = new int[numDefine32];
    public String waMandreelCacheAudioFilesPath = "";
    public static VariableSet variableSet = new VariableSet();
    public GmandreelFs gMandreelFs = new GmandreelFs();
    public double gMandreelTimestampFs = 0.0;
    public String[] webAudioPreloadAudioFiles = new String[0];
    public int webAudioPreloadCurrentFile = 0;
    public boolean webAudioPreloadAsync = false;
    public static int waMandreelAudioBuffersNum = 0;
    public int waMandreelAudioBuffersLoaded = 0;

    public String mwebAudioPreloadState = "start";
    public List<String> mwebAudioPreloadAssets = new ArrayList<>();
    public int mwebAudioCurrentPreloadAsset = 0;
    public static String mwebAudioAsyncFiles = "";
    public static String mwebListAudioAsyncFiles = "";
    public static int mwebListAudioAsyncFilesPos = 0;
    public int mwebTotalPreloadingFiles = 0;
    public static int mwebCurrentPreloadingFiles = 0;
    public int mandreelTotalPogfileSize = 0;

    public static MandreelElement waMandreelMusicElement;
    public static String waMandreelMusicElementFilename = "";
    public Navigator navigator = new Navigator();
    public static double waMandreelMusicElementVolume = 1.0;
    public static int mandreelAudioStreamFuncPtr = 0;
    public boolean mandreelAudioCreateStreamCreated = false;
    public static String mandreelFlashaudioServer = "";
    public static boolean mandreelFlashaudioLite = false;
    public static boolean mandreelFlashaudioMusicaudiotag = true;
    public static int mandreelAudioFlashLastBufferCreated = 0;
    public static int mandreelAudioFlashLastBufferCreatedSwf = 0;
    public static boolean ninjaLoaded = false;
    public String maudiotagPreloadState = "start";
    public List<String> maudiotagPreloadAssets = new ArrayList<>();
    public int maudiotagCurrentPreloadAsset = 0;
    public boolean maudiotagPreloadAsync = false;
    public List<Number> maudiotagDurations = new ArrayList<>();
    public int maudiotagChannelsCreated = 0;
    public List<Number> maudiotagChannelsLoaded = new ArrayList<>();
    public boolean maudiotagAudioSpriteFound = false;
    public String audiotagAudioSprite = "";
    public static boolean jsMandreelFlashSocketSwfLoaded = false;

    public interface NullMandreelAudio {
        void nullMandreelAudio(int sp);
    }

    public interface MandreelAudioUseMusicFunctions {
        void mandreelAudioUseMusicFunctions(int sp);
    }

    public static NullMandreelAudio mandreelAudioInit = new NullMandreelAudio() {
        @Override
        public void nullMandreelAudio(int sp) {
            commonVariable.rg0 = 0;
        }
    };
    public static NullMandreelAudio mandreelAudioEnd = new NullMandreelAudio() {
        @Override
        public void nullMandreelAudio(int sp) {
            commonVariable.rg0 = 0;
        }
    };
    public static NullMandreelAudio mandreelAudioUpdate = new NullMandreelAudio() {
        @Override
        public void nullMandreelAudio(int sp) {
            commonVariable.rg0 = 0;
        }
    };
    public static NullMandreelAudio mandreelAudioCreateBuffer = new NullMandreelAudio() {
        @Override
        public void nullMandreelAudio(int sp) {
            commonVariable.rg0 = 0;
        }
    };
    public static NullMandreelAudio mandreelAudioPlayChannel = new NullMandreelAudio() {
        @Override
        public void nullMandreelAudio(int sp) {
            commonVariable.rg0 = 0;
        }
    };
    public static NullMandreelAudio mandreelAudioStopChannel = new NullMandreelAudio() {
        @Override
        public void nullMandreelAudio(int sp) {
            commonVariable.rg0 = 0;
        }
    };
    public static NullMandreelAudio mandreelAudioSetChannelVolume = new NullMandreelAudio() {
        @Override
        public void nullMandreelAudio(int sp) {
            commonVariable.rg0 = 0;
        }
    };
    public static NullMandreelAudio mandreelAudioSetChannelPan = new NullMandreelAudio() {
        @Override
        public void nullMandreelAudio(int sp) {
            commonVariable.rg0 = 0;
        }
    };
    public static NullMandreelAudio mandreelAudioSetChannelPitch = new NullMandreelAudio() {
        @Override
        public void nullMandreelAudio(int sp) {
            commonVariable.rg0 = 0;
        }
    };
    public static NullMandreelAudio mandreelAudioPlayMusic = new NullMandreelAudio() {
        @Override
        public void nullMandreelAudio(int sp) {
            commonVariable.rg0 = 0;
        }
    };
    public static NullMandreelAudio mandreelAudioStopMusic = new NullMandreelAudio() {
        @Override
        public void nullMandreelAudio(int sp) {
            commonVariable.rg0 = 0;
        }
    };
    public static NullMandreelAudio mandreelAudioCheckBuffersPending = new NullMandreelAudio() {
        @Override
        public void nullMandreelAudio(int sp) {
            commonVariable.rg0 = 0;
        }
    };
    public static NullMandreelAudio mandreelAudioSetMusicVol = new NullMandreelAudio() {
        @Override
        public void nullMandreelAudio(int sp) {
            commonVariable.rg0 = 0;
        }
    };
    public static MandreelAudioUseMusicFunctions mandreelAudioUseMusicFunctionsNew = new MandreelAudioUseMusicFunctions() {
        @Override
        public void mandreelAudioUseMusicFunctions(int sp) {
            commonVariable.rg0 = 0;
        }
    };

    public static void mandreelStartAudio(String audioServer, String audioUrl) {
        boolean webAudioDataAvailable = false;
        boolean flashAudioDataAvailable = false;
        boolean flashLiteAudioDataAvailable = false;
        boolean audiotagsDataAvailable = false;
        if (flashAudioDataAvailable && commonVariable.mandreelAudioDriver == "null") {
            commonVariable.mandreelAudioDriver = "flash";
            flMainAudioDriver(audioServer, audioUrl);
        }
        if (flashLiteAudioDataAvailable && commonVariable.mandreelAudioDriver == "null") {
            commonVariable.mandreelAudioDriver = "flashlite";
            mandreelFlashaudioLite = true;
            flMainAudioDriver("", "");
        }
        if (audiotagsDataAvailable && commonVariable.mandreelAudioDriver == "null") {
            commonVariable.mandreelAudioDriver = "audiotag";
            atMainAudioDriver();
        }
        if (commonVariable.mandreelAudioDriver == "null") {
            nullMainAudioDriver();
        }
        dump("AudioDriver (" + commonVariable.mandreelAudioDriver + ")");
    }

    public static void waMandreelAudioCreateBuffer(int sp) {
        int spTemp = sp;
        int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        int maxChannels = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        String fileName = getStringFromPtr(ptrFileName).toLowerCase();
        waImpMandreelAudioCreateBuffer(fileName);
        commonVariable.rg0 = 0;
    }

    public static void waMandreelAudioSetChannelVolume(int sp) {
        int spTemp = sp;
        int channel = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double vol = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
        waImpMandreelAudioSetChannelVolume(channel, vol);
    }

    public static void waMandreelAudioSetChannelPan(int sp) {
        int spTemp = sp;
        int channel = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double pan = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
    }

    public static void waMandreelAudioSetChannelPitch(int sp) {
        int spTemp = sp;
        int channel = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double pitch = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
        waImpMandreelAudioSetChannelPitch(channel, pitch);
    }

    public static void waMandreelAudioUseMusicFunctions(int sp) {
        commonVariable.rg0 = webAudioUseMusicFunctions ? 1 : 0;
    }

    public static void waMandreelAudioPlayMusic(int sp) {
        int spTemp = sp;
        int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        String fileName = getStringFromPtr(ptrFileName).toLowerCase();
        waImpMandreelAudioPlayMusic(fileName);
    }

    public static void waMandreelAudioStopMusic(int sp) {
        waImpMandreelAudioStopMusic();
    }

    public static void waMandreelAudioSetMusicVol(int sp) {
        int spTemp = sp;
        double vol = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
        waImpMandreelAudioSetMusicVol(vol);
    }

    public static void waInitWebAudio() {
        if (variableSet.preCreatedWebAudioContext != null) {
            webAudioContext = variableSet.preCreatedWebAudioContext;
        }
    }

    public static String waGetFileNameNoExt(String fileName) {
        String fileNameNoExt = fileName.toLowerCase();
        return fileNameNoExt;
    }

    public int waImpMandreelAudioCheckBuffersPending() {
        return waMandreelAudioBuffersNum - waMandreelAudioBuffersLoaded;
    }

    public static void waImpMandreelAudioCreateBuffer(String fileName) {
        if (webAudioContext != null) {
            String fileNameNoExt = waGetFileNameNoExt(fileName);
            String buffer = webAudioBuffers[Integer.parseInt(fileNameNoExt)];
            if (buffer == null && buffer != "invalid") {
                waMandreelAudioBuffersNum += 1;
            }
        }
    }

    public static void waImpMandreelAudioSetChannelVolume(int channel, double vol) {
        if (webAudioContext != null) {
            int gain = webAudioGain[channel];
            // TODO:自行注释，如遇报错可解开
//            if (gain != null) {
//                gain = vol;
//            }
        }
    }

    public static void waImpMandreelAudioSetChannelPitch(int channel, double pitch) {
        if (webAudioContext != null) {
            int chn = webAudioChannels[channel];
            // TODO:自行注释，如遇报错可解开
//            if (chn != null) {
//                chn = pitch;
//            }
        }
    }

    public static void mwebCallbackAsync() {
        mwebListAudioAsyncFilesPos += 1;
        if (mwebListAudioAsyncFilesPos >= mwebListAudioAsyncFiles.length()) {
            mwebListAudioAsyncFiles = null;
            mwebAudioAsyncFiles = null;
            return;
        }
    }

    public static void mwebCallbackAsyncPreload() {
        mwebCurrentPreloadingFiles += 1;
    }

    public static void mandreelWebAudioPreloadAssets() {
    }

    public static void waImpMandreelAudioPlayMusic(String fileName) {
        String fileNameNoExt = waGetFileNameNoExt(fileName);
        String fileNameFull = commonVariable.gMandreelWorkingFolder + fileNameNoExt + ".ogg";

        if (waMandreelMusicElementFilename != fileNameFull) {
            waImpMandreelAudioStopMusic();
            MandreelElement audio = mandreelDocument.createElement("audio");
            waMandreelMusicElement = audio;
            waMandreelMusicElementFilename = fileNameFull;
        }
    }

    public static void waImpMandreelAudioStopMusic() {
        if (waMandreelMusicElement != null) {
            waMandreelMusicElement = null;
            waMandreelMusicElementFilename = "";
        }
    }

    public static void waImpMandreelAudioSetMusicVol(double vol) {
        waMandreelMusicElementVolume = vol;
        if (waMandreelMusicElement != null) {
            waMandreelMusicElement.volume = waMandreelMusicElementVolume;
        }
    }

    public static void mandreelAudioRequestSoundData(String soundData) {
        int n = soundData.length() / numDefine2;
        int offset2 = 0;
        while (n > 0) {
            int n2 = n;
            if (n2 > numDefine1024) {
                n2 = numDefine1024;
            }
            int sp = gStackPointer + numDefine100 * numDefine1024;
            int ptr = gStackPointer + numDefine200 * numDefine1024;
            int spNew = sp >> numDefine2;
            heapClassInst.heap32[spNew] = ptr;
            heapClassInst.heap32[spNew + 1] = n2;
            functionTable.get(mandreelAudioStreamFuncPtr >> numDefine2).accept(sp);

            int offset = ptr >> numDefine2;
            int size = n2 * numDefine2;
            offset2 += n2 * numDefine2;
            n -= n2;
        }
    }

    public static void mandreelSendmsgFlash(String msg) {
        if (mandreelFlashaudioServer != "") {
            MandreelBase iframeWin = mandreelDocument.getElementById("ninja-iframe").contentWindow;
        }
    }

    public static void flMandreelAudioInit(int sp) {
        mandreelSendmsgFlash("init " + commonVariable.gMandreelWorkingFolder);
    }

    public static void mandreelFlashaudioliteCreateBuffer(String fileName) {
        mandreelAudioFlashLastBufferCreated += 1;
        mandreelSendmsgFlash("createBuffer " + waGetFileNameNoExt(fileName) + " " + mandreelAudioFlashLastBufferCreated);
    }

    public static void flMandreelAudioCreateBuffer(int sp) {
        int spTemp = sp;
        int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        String fileName = getStringFromPtr((ptrFileName)).toLowerCase();
        mandreelFlashaudioliteCreateBuffer(fileName);
    }

    public static boolean flInternalMandreelAudioCheckBuffersPending() {
        return mandreelFlashaudioLite && mandreelAudioFlashLastBufferCreatedSwf != mandreelAudioFlashLastBufferCreated;
    }

    public static void flMandreelAudioCheckBuffersPending(int sp) {
        commonVariable.rg0 = 0;
        if (flInternalMandreelAudioCheckBuffersPending()) {
            commonVariable.rg0 = 1;
        }
        dump(
                "flMandreelAudioCheckBuffersPending (" +
                        Integer.toString(commonVariable.rg0) +
                        ") (" +
                        Integer.toString(mandreelAudioFlashLastBufferCreatedSwf) +
                        ") (" +
                        Integer.toString(mandreelAudioFlashLastBufferCreated) +
                        ")"
        );
    }

    public static void flMandreelAudioPlayChannel(int sp) {
        int spTemp = sp;
        int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        int channel = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double vol = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
        int loop = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double pitch = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
        String fileName = getStringFromPtr(ptrFileName).toLowerCase();
        mandreelSendmsgFlash("playChannel " + fileName + " " + Integer.toString(channel) + " " + Integer.toString(loop) + " " + (vol) + " " + (pitch));
        commonVariable.rg0 = 0;
    }

    public static void flMandreelAudioStopChannel(int sp) {
        int spTemp = sp;
        int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        int channel = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double index = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;

        mandreelSendmsgFlash("stopChannel " + channel);
    }

    public static void flMandreelAudioSetChannelVolume(int sp) {
        int spTemp = sp;
        int channel = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double vol = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;

        mandreelSendmsgFlash("setChannelVolume " + Integer.toString(channel) + " " + (vol));
    }

    public static void flMandreelAudioSetChannelPan(int sp) {
        int spTemp = sp;
        int channel = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double pan = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
        mandreelSendmsgFlash("setChannelPan " + Integer.toString(channel) + " " + (pan));
    }

    public static void flMandreelAudioSetChannelPitch(int sp) {
        int spTemp = sp;
        int channel = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double pitch = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
        mandreelSendmsgFlash("setChannelPitch " + Integer.toString(channel) + " " + (pitch));
    }

    public static void flMainAudioDriver(String audioServer, String audioUrl) {
        mandreelFlashaudioServer = audioServer;
        if (mandreelFlashaudioLite) {
            mandreelFlashaudioServer = "";
        }
    }

    public interface FlMandreelAudioInit {
        void flMandreelAudioInit(int sp);
    }

    public interface FlMandreelAudioCreateBuffer {
        void flMandreelAudioCreateBuffer(int sp);
    }

    public interface FlMandreelAudioPlayChannel {
        void flMandreelAudioPlayChannel(int sp);
    }

    public interface FlMandreelAudioStopChannel {
        void flMandreelAudioStopChannel(int sp);
    }

    public interface FlMandreelAudioSetChannelVolume {
        void flMandreelAudioSetChannelVolume(int sp);
    }

    public interface FlMandreelAudioSetChannelPan {
        void flMandreelAudioSetChannelPan(int sp);
    }

    public interface FlMandreelAudioSetChannelPitch {
        void flMandreelAudioSetChannelPitch(int sp);
    }

    public interface WaMandreelAudioUseMusicFunctions {
        void waMandreelAudioUseMusicFunctions(int sp);
    }

    public interface WaMandreelAudioPlayMusic {
        void waMandreelAudioPlayMusic(int sp);
    }

    public interface WaMandreelAudioStopMusic {
        void waMandreelAudioStopMusic(int sp);
    }

    public interface WaMandreelAudioSetMusicVol {
        void waMandreelAudioSetMusicVol(int sp);
    }

    public interface FlMandreelAudioCheckBuffersPending {
        void flMandreelAudioCheckBuffersPending(int sp);
    }

    public static void flMapMandreelAudioFunctions() {
        FlMandreelAudioInit mandreelAudioInit = new FlMandreelAudioInit() {
            @Override
            public void flMandreelAudioInit(int sp) {
                mandreelSendmsgFlash("init " + commonVariable.gMandreelWorkingFolder);
            }
        };
        FlMandreelAudioCreateBuffer mandreelAudioCreateBuffer = new FlMandreelAudioCreateBuffer() {
            @Override
            public void flMandreelAudioCreateBuffer(int sp) {
                int spTemp = sp;
                int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                String fileName = getStringFromPtr((ptrFileName)).toLowerCase();
                mandreelFlashaudioliteCreateBuffer(fileName);
            }
        };
        FlMandreelAudioPlayChannel mandreelAudioPlayChannel = new FlMandreelAudioPlayChannel() {
            @Override
            public void flMandreelAudioPlayChannel(int sp) {
                int spTemp = sp;
                int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                int channel = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                double vol = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;
                int loop = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                double pitch = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;
                String fileName = getStringFromPtr(ptrFileName).toLowerCase();
                mandreelSendmsgFlash("playChannel " + fileName + " " + Integer.toString(channel) + " " + Integer.toString(loop) + " " + (vol) + " " + (pitch));
                commonVariable.rg0 = 0;
            }
        };
        FlMandreelAudioStopChannel mandreelAudioStopChannel = new FlMandreelAudioStopChannel() {
            @Override
            public void flMandreelAudioStopChannel(int sp) {
                int spTemp = sp;
                int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                int channel = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                double index = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;

                mandreelSendmsgFlash("stopChannel " + channel);
            }
        };
        FlMandreelAudioSetChannelVolume mandreelAudioSetChannelVolume = new FlMandreelAudioSetChannelVolume() {
            @Override
            public void flMandreelAudioSetChannelVolume(int sp) {
                int spTemp = sp;
                int channel = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                double vol = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;

                mandreelSendmsgFlash("setChannelVolume " + Integer.toString(channel) + " " + (vol));
            }
        };
        FlMandreelAudioSetChannelPan mandreelAudioSetChannelPan = new FlMandreelAudioSetChannelPan() {
            @Override
            public void flMandreelAudioSetChannelPan(int sp) {
                int spTemp = sp;
                int channel = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                double pan = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;
                mandreelSendmsgFlash("setChannelPan " + Integer.toString(channel) + " " + (pan));
            }
        };
        FlMandreelAudioSetChannelPitch mandreelAudioSetChannelPitch = new FlMandreelAudioSetChannelPitch() {
            @Override
            public void flMandreelAudioSetChannelPitch(int sp) {
                int spTemp = sp;
                int channel = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                double pitch = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;
                mandreelSendmsgFlash("setChannelPitch " + Integer.toString(channel) + " " + (pitch));
            }
        };
        if (mandreelFlashaudioMusicaudiotag) {
            WaMandreelAudioUseMusicFunctions mandreelAudioUseMusicFunctionsNew = new WaMandreelAudioUseMusicFunctions() {
                @Override
                public void waMandreelAudioUseMusicFunctions(int sp) {
                    commonVariable.rg0 = webAudioUseMusicFunctions ? 1 : 0;
                }
            };
            WaMandreelAudioPlayMusic mandreelAudioPlayMusic = new WaMandreelAudioPlayMusic() {
                @Override
                public void waMandreelAudioPlayMusic(int sp) {
                    int spTemp = sp;
                    int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
                    spTemp += numDefine4;
                    String fileName = getStringFromPtr(ptrFileName).toLowerCase();
                    waImpMandreelAudioPlayMusic(fileName);
                }
            };
            WaMandreelAudioStopMusic mandreelAudioStopMusic = new WaMandreelAudioStopMusic() {
                @Override
                public void waMandreelAudioStopMusic(int sp) {
                    waImpMandreelAudioStopMusic();
                }
            };
            WaMandreelAudioSetMusicVol mandreelAudioSetMusicVol = new WaMandreelAudioSetMusicVol() {
                @Override
                public void waMandreelAudioSetMusicVol(int sp) {
                    int spTemp = sp;
                    double vol = heapClassInst.heapFloat[spTemp >> numDefine2];
                    spTemp += numDefine4;
                    waImpMandreelAudioSetMusicVol(vol);
                }
            };
        } else {
            dump("WARNING: flash music functions not supported");
        }
        FlMandreelAudioCheckBuffersPending mandreelAudioCheckBuffersPending = new FlMandreelAudioCheckBuffersPending() {
            @Override
            public void flMandreelAudioCheckBuffersPending(int sp) {
                commonVariable.rg0 = 0;
                if (flInternalMandreelAudioCheckBuffersPending()) {
                    commonVariable.rg0 = 1;
                }
                dump(
                        "flMandreelAudioCheckBuffersPending (" +
                                Integer.toString(commonVariable.rg0) +
                                ") (" +
                                Integer.toString(mandreelAudioFlashLastBufferCreatedSwf) +
                                ") (" +
                                Integer.toString(mandreelAudioFlashLastBufferCreated) +
                                ")"
                );
            }
        };
    }

    public static void receiveMessage2(String event) {
        ninjaLoaded = true;
        flMapMandreelAudioFunctions();
    }

    public static void flashReady() {
        flMapMandreelAudioFunctions();
    }

    public static void nullMainAudioDriver() {
        NullMandreelAudio mandreelAudioInit = new NullMandreelAudio() {
            @Override
            public void nullMandreelAudio(int sp) {
                commonVariable.rg0 = 0;
            }
        };
        NullMandreelAudio mandreelAudioEnd = new NullMandreelAudio() {
            @Override
            public void nullMandreelAudio(int sp) {
                commonVariable.rg0 = 0;
            }
        };
        NullMandreelAudio mandreelAudioUpdate = new NullMandreelAudio() {
            @Override
            public void nullMandreelAudio(int sp) {
                commonVariable.rg0 = 0;
            }
        };
        NullMandreelAudio mandreelAudioCreateBuffer = new NullMandreelAudio() {
            @Override
            public void nullMandreelAudio(int sp) {
                commonVariable.rg0 = 0;
            }
        };
        NullMandreelAudio mandreelAudioPlayChannel = new NullMandreelAudio() {
            @Override
            public void nullMandreelAudio(int sp) {
                commonVariable.rg0 = 0;
            }
        };
        NullMandreelAudio mandreelAudioStopChannel = new NullMandreelAudio() {
            @Override
            public void nullMandreelAudio(int sp) {
                commonVariable.rg0 = 0;
            }
        };
        NullMandreelAudio mandreelAudioSetChannelVolume = new NullMandreelAudio() {
            @Override
            public void nullMandreelAudio(int sp) {
                commonVariable.rg0 = 0;
            }
        };
        NullMandreelAudio mandreelAudioSetChannelPan = new NullMandreelAudio() {
            @Override
            public void nullMandreelAudio(int sp) {
                commonVariable.rg0 = 0;
            }
        };
        NullMandreelAudio mandreelAudioSetChannelPitch = new NullMandreelAudio() {
            @Override
            public void nullMandreelAudio(int sp) {
                commonVariable.rg0 = 0;
            }
        };
        WaMandreelAudioUseMusicFunctions mandreelAudioUseMusicFunctionsNew = new WaMandreelAudioUseMusicFunctions() {
            @Override
            public void waMandreelAudioUseMusicFunctions(int sp) {
                commonVariable.rg0 = webAudioUseMusicFunctions ? 1 : 0;
            }
        };
        WaMandreelAudioPlayMusic mandreelAudioPlayMusic = new WaMandreelAudioPlayMusic() {
            @Override
            public void waMandreelAudioPlayMusic(int sp) {
                int spTemp = sp;
                int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                String fileName = getStringFromPtr(ptrFileName).toLowerCase();
                waImpMandreelAudioPlayMusic(fileName);
            }
        };
        WaMandreelAudioStopMusic mandreelAudioStopMusic = new WaMandreelAudioStopMusic() {
            @Override
            public void waMandreelAudioStopMusic(int sp) {
                waImpMandreelAudioStopMusic();
            }
        };
        WaMandreelAudioSetMusicVol mandreelAudioSetMusicVol = new WaMandreelAudioSetMusicVol() {
            @Override
            public void waMandreelAudioSetMusicVol(int sp) {
                int spTemp = sp;
                double vol = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;
                waImpMandreelAudioSetMusicVol(vol);
            }
        };
    }

    public static void atMandreelAudioCheckBuffersPending(int sp) {
        commonVariable.rg0 = 0;
    }

    public static void atMandreelAudioCreateBuffer(int sp) {
        int spTemp = sp;
        int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        int maxChannels = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        String fileName = getStringFromPtr(ptrFileName).toLowerCase();
        commonVariable.rg0 = 0;
    }

    public static void atMandreelAudioPlayChannel(int sp) {
        int spTemp = sp;
        int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        int channel = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double vol = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
        int loop = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double pitch = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
        String fileName = getStringFromPtr((ptrFileName)).toLowerCase();
        commonVariable.rg0 = 0;
    }

    public static void atMandreelAudioStopChannel(int sp) {
        int spTemp = sp;
        int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        int channel = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double index = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
    }

    public static void atMandreelAudioSetChannelVolume(int sp) {
        int spTemp = sp;
        int channel = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double vol = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
    }

    public static void atMandreelAudioSetChannelPan(int sp) {
        int spTemp = sp;
        int channel = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double pan = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
    }

    public static void atMandreelAudioSetChannelPitch(int sp) {
        int spTemp = sp;
        int channel = heapClassInst.heap32[spTemp >> numDefine2];
        spTemp += numDefine4;
        double pitch = heapClassInst.heapFloat[spTemp >> numDefine2];
        spTemp += numDefine4;
    }

    public static void atmandreelAudioUseMusicFunctions(int sp) {
        commonVariable.rg0 = 1;
    }

    public interface AtMandreelAudioCreateBuffer {
        void atMandreelAudioCreateBuffer(int sp);
    }

    public interface AtMandreelAudioPlayChannel {
        void atMandreelAudioPlayChannel(int sp);
    }

    public interface AtMandreelAudioStopChannel {
        void atMandreelAudioStopChannel(int sp);
    }

    public interface AtMandreelAudioSetChannelVolume {
        void atMandreelAudioSetChannelVolume(int sp);
    }

    public interface AtMandreelAudioSetChannelPan {
        void atMandreelAudioSetChannelPan(int sp);
    }

    public interface AtMandreelAudioSetChannelPitch {
        void atMandreelAudioSetChannelPitch(int sp);
    }

    public interface AtmandreelAudioUseMusicFunctions {
        void atmandreelAudioUseMusicFunctions(int sp);
    }

    public interface AtMandreelAudioCheckBuffersPending {
        void atMandreelAudioCheckBuffersPending(int sp);
    }

    public static void atMainAudioDriver() {
        AtMandreelAudioCreateBuffer mandreelAudioCreateBuffer = new AtMandreelAudioCreateBuffer() {
            @Override
            public void atMandreelAudioCreateBuffer(int sp) {
                int spTemp = sp;
                int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                int maxChannels = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                String fileName = getStringFromPtr(ptrFileName).toLowerCase();
                commonVariable.rg0 = 0;
            }
        };
        AtMandreelAudioPlayChannel mandreelAudioPlayChannel = new AtMandreelAudioPlayChannel() {
            @Override
            public void atMandreelAudioPlayChannel(int sp) {
                int spTemp = sp;
                int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                int channel = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                double vol = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;
                int loop = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                double pitch = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;
                String fileName = getStringFromPtr((ptrFileName)).toLowerCase();
                commonVariable.rg0 = 0;
            }
        };
        AtMandreelAudioStopChannel mandreelAudioStopChannel = new AtMandreelAudioStopChannel() {
            @Override
            public void atMandreelAudioStopChannel(int sp) {
                int spTemp = sp;
                int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                int channel = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                double index = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;
            }
        };
        AtMandreelAudioSetChannelVolume mandreelAudioSetChannelVolume = new AtMandreelAudioSetChannelVolume() {
            @Override
            public void atMandreelAudioSetChannelVolume(int sp) {
                int spTemp = sp;
                int channel = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                double vol = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;
            }
        };
        AtMandreelAudioSetChannelPan mandreelAudioSetChannelPan = new AtMandreelAudioSetChannelPan() {
            @Override
            public void atMandreelAudioSetChannelPan(int sp) {
                int spTemp = sp;
                int channel = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                double pan = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;
            }
        };
        AtMandreelAudioSetChannelPitch mandreelAudioSetChannelPitch = new AtMandreelAudioSetChannelPitch() {
            @Override
            public void atMandreelAudioSetChannelPitch(int sp) {
                int spTemp = sp;
                int channel = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                double pitch = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;
            }
        };
        AtmandreelAudioUseMusicFunctions mandreelAudioUseMusicFunctionsNew = new AtmandreelAudioUseMusicFunctions() {
            @Override
            public void atmandreelAudioUseMusicFunctions(int sp) {
                commonVariable.rg0 = 1;
            }
        };
        WaMandreelAudioPlayMusic mandreelAudioPlayMusic = new WaMandreelAudioPlayMusic() {
            @Override
            public void waMandreelAudioPlayMusic(int sp) {
                int spTemp = sp;
                int ptrFileName = heapClassInst.heap32[spTemp >> numDefine2];
                spTemp += numDefine4;
                String fileName = getStringFromPtr(ptrFileName).toLowerCase();
                waImpMandreelAudioPlayMusic(fileName);
            }
        };
        WaMandreelAudioStopMusic mandreelAudioStopMusic = new WaMandreelAudioStopMusic() {
            @Override
            public void waMandreelAudioStopMusic(int sp) {
                waImpMandreelAudioStopMusic();
            }
        };
        AtMandreelAudioCheckBuffersPending mandreelAudioCheckBuffersPending = new AtMandreelAudioCheckBuffersPending() {
            @Override
            public void atMandreelAudioCheckBuffersPending(int sp) {
                commonVariable.rg0 = 0;
            }
        };
        WaMandreelAudioSetMusicVol mandreelAudioSetMusicVol = new WaMandreelAudioSetMusicVol() {
            @Override
            public void waMandreelAudioSetMusicVol(int sp) {
                int spTemp = sp;
                double vol = heapClassInst.heapFloat[spTemp >> numDefine2];
                spTemp += numDefine4;
                waImpMandreelAudioSetMusicVol(vol);
            }
        };
    }

    public static void jsMandreelFlashSocketReady() {
        jsMandreelFlashSocketSwfLoaded = true;
    }

    public static void jsMandreelFlashSocketOnError(String message) {
        int id = Integer.parseInt(message);

        int sp = gStackPointer + numDefine512 * numDefine1024;

        dump("on error " + Integer.toString(id));

        heapClassInst.heap32[sp >> numDefine2] = id;
        mandreelFlashTcpOnError(sp);
    }

    public static void globalILandscape02Vtx(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = zl10raycastBar;
        heapClassInst.heap32[g0] = numDefine8;
        r0 = r0 >> numDefine2;
        znwj(i7);
        heapClassInst.heap32[r0 + numDefine10006] = commonVariable.rg0;
        heapClassInst.heap32[g0] = commonVariable.rg0;
        heapClassInst.heap32[g0 + 1] = 0;
        getTimeOfDay(i7);
        heapClassInst.heap32[r0 + numDefine10001] = 0;
        heapClassInst.heap32[r0 + numDefine10005] = 0;
        heapClassInst.heap32[r0 + numDefine10004] = numDefine9999;
        heapClassInst.heap32[r0 + numDefine10003] = 0;
        heapClassInst.heap32[r0 + numDefine10002] = 0;

    }

    public static void globalDLandscape02Vtx(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = zl10raycastBar;
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine10006];
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);

    }

    public static void zn17btTypedConstraint21setupSolverConstraintER20btAlignedObjectArrayI18btSolverConstraintEiif(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;

        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;

    }

    public static void zn17btTypedConstraint23solveConstraintObsoleteER11btRigidBodyS1F(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;

    }

    public static void zn13BenchmarkDemo10createWallERK9btVector3iS2(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        double f5 = 0.0;
        double f6 = 0.0;
        double f7 = 0.0;
        double f8 = 0.0;
        double f9 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg96;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = gNumAlignedAllocs;
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        r2 = heapClassInst.heap32[r1];
        f0 = heapClassInst.heapFloat[r0 + numDefine2];
        f1 = heapClassInst.heapFloat[r0 + 1];
        f2 = heapClassInst.heapFloat[r0];
        r2 = (r2 + 1) | 0;
        heapClassInst.heap32[r1] = r2;
        heapClassInst.heap32[g0] = numDefine71;
        mallocNew(i7);
        r1 = commonVariable.rg0;
        r2 = heapClassInst.heap32[fp];
        if (r1 != 0) {
            r3 = 0;
            r4 = (r1 + numDefine4) | 0;
            r3 = (r3 - r4) | 0;
            r3 = r3 & numDefine15;
            r3 = (r1 + r3) | 0;
            r4 = (r3 + numDefine4) | 0;
            r3 = r3 >> numDefine2;
            heapClassInst.heap32[r3] = r1;
            r1 = r4;
        }
        r3 = r1 >> numDefine2;
        heapClassInst.heap32[r3 + numDefine2] = 0;
        heapClassInst.heap32[r3 + numDefine3] = numDefine53216;
        heapClassInst.heap32[r3 + numDefine4] = numDefine53216;
        heapClassInst.heap32[r3 + numDefine5] = numDefine53216;
        r4 = ztv10btBoxShape;
        heapClassInst.heap32[r3 + numDefine6] = 0;
        r4 = (r4 + numDefine8) | 0;
        heapClassInst.heap32[r3 + numDefine11] = numDefine58986;
        heapClassInst.heap32[r3] = r4;
        f3 = numDefineNegFloat028;
        f2 = f2 + f3;
        heapClassInst.heap32[r3 + 1] = 0;
        f1 = f1 + f3;
        heapClassInst.heapFloat[r3 + numDefine7] = (float) f2;
        f0 = f0 + f3;
        heapClassInst.heapFloat[r3 + numDefine8] = (float) f1;
        heapClassInst.heapFloat[r3 + numDefine9] = (float) f0;
        r4 = sp + numDefineNeg16;
        heapClassInst.heap32[r3 + numDefine10] = 0;
        r3 = r4 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg4] = 0;
        heapClassInst.heap32[r3 + 1] = 0;
        heapClassInst.heap32[r3 + numDefine2] = 0;
        heapClassInst.heap32[r3 + numDefine3] = 0;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = numDefine53216;
        heapClassInst.heap32[g0 + numDefine2] = r4;
        znk10btBoxShape21calculateLocalInertiaEfR9btVector3(i7);
        f4 = heapClassInst.heapFloat[r0 + 1];
        f0 = heapClassInst.heapFloat[r0 + numDefine2];
        r0 = sp + numDefineNeg80;
        r3 = r0 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg20] = numDefine53216;
        heapClassInst.heap32[r3 + 1] = 0;
        heapClassInst.heap32[r3 + numDefine2] = 0;
        heapClassInst.heap32[r3 + numDefine3] = 0;
        heapClassInst.heap32[r3 + numDefine4] = 0;
        heapClassInst.heap32[r3 + numDefine5] = numDefine53216;
        heapClassInst.heap32[r3 + numDefine6] = 0;
        heapClassInst.heap32[r3 + numDefine7] = 0;
        heapClassInst.heap32[r3 + numDefine8] = 0;
        heapClassInst.heap32[r3 + numDefine9] = 0;
        heapClassInst.heap32[r3 + numDefine10] = numDefine53216;
        heapClassInst.heap32[r3 + numDefine11] = 0;
        f1 = f0 + f0;
        f2 = numDefineNeg12;
        heapClassInst.heap32[r3 + numDefine12] = 0;
        heapClassInst.heap32[r3 + numDefine13] = 0;
        f2 = f1 * f2;
        f3 = numDefineFloat05;
        f3 = f2 * f3;
        f2 = f4 + f4;
        r5 = numDefine12;
        heapClassInst.heap32[r3 + numDefine14] = 0;
        heapClassInst.heap32[r3 + numDefine15] = 0;
        repeat4:
        while (true) {
            if (!(r5 < 1)) {
                r4 = 0;
                repeat8:
                while (true) {
                    r6 = r2 >> numDefine2;
                    f5 = r4;
                    f6 = 0;
                    f7 = heapClassInst.heapFloat[r6];
                    f8 = heapClassInst.heapFloat[r6 + numDefine2];
                    f9 = heapClassInst.heapFloat[r6 + 1];
                    f5 = f5 * f1;
                    f6 = f7 + f6;
                    f5 = f5 + f3;
                    f7 = f9 + f4;
                    heapClassInst.heapFloat[r3 + numDefine12] = (float) f6;
                    f5 = f8 + f5;
                    heapClassInst.heapFloat[r3 + numDefine13] = (float) f7;
                    r6 = zl14benchmarkDemo4;
                    heapClassInst.heapFloat[r3 + numDefine14] = (float) f5;
                    r7 = r6 >> numDefine2;
                    heapClassInst.heap32[r3 + numDefine15] = 0;
                    r7 = heapClassInst.heap32[r7];
                    r7 = r7 >> numDefine2;
                    r7 = heapClassInst.heap32[r7 + numDefine2];
                    heapClassInst.heap32[g0] = r6;
                    heapClassInst.heap32[g0 + 1] = numDefine53216;
                    heapClassInst.heap32[g0 + numDefine2] = r0;
                    heapClassInst.heap32[g0 + numDefine3] = r1;
                    r4 = (r4 + 1) | 0;
                    functionTable.get(r7 >> numDefine2).accept(i7);
                    if (r5 != r4) {
                        continue repeat8;
                    } else {
                        break repeat8;
                    }
                }
            }
            r5 = (r5 + -1) | 0;
            f4 = f4 + f2;
            f3 = f3 + f0;
            if (r5 == 0) {
                break repeat4;
            } else {
                continue repeat4;
            }
        }
        return;
    }

    public static void zn13BenchmarkDemo19createLargeMeshBodyEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int label = 0;
        i7 = sp + numDefineNeg80;
        int g0 = i7 >> numDefine2;
        r0 = sp + numDefineNeg64;
        r1 = r0 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg16] = numDefine53216;
        heapClassInst.heap32[r1 + 1] = 0;
        heapClassInst.heap32[r1 + numDefine2] = 0;
        heapClassInst.heap32[r1 + numDefine3] = 0;
        heapClassInst.heap32[r1 + numDefine4] = 0;
        heapClassInst.heap32[r1 + numDefine5] = numDefine53216;
        heapClassInst.heap32[r1 + numDefine6] = 0;
        heapClassInst.heap32[r1 + numDefine7] = 0;
        heapClassInst.heap32[r1 + numDefine8] = 0;
        heapClassInst.heap32[r1 + numDefine9] = 0;
        heapClassInst.heap32[r1 + numDefine10] = numDefine53216;
        heapClassInst.heap32[r1 + numDefine11] = 0;
        heapClassInst.heap32[r1 + numDefine12] = 0;
        heapClassInst.heap32[r1 + numDefine13] = 0;
        r2 = 0;
        heapClassInst.heap32[r1 + numDefine14] = 0;
        heapClassInst.heap32[r1 + numDefine15] = 0;
        repeat1:
        while (true) {
            r3 = gNumAlignedAllocs;
            r3 = r3 >> numDefine2;
            r4 = heapClassInst.heap32[r3];
            r5 = (r4 + 1) | 0;
            heapClassInst.heap32[r3] = r5;
            heapClassInst.heap32[g0] = numDefine103;
            mallocNew(i7);
            r5 = commonVariable.rg0;
            if (r5 != 0) {
                r6 = 0;
                r7 = (r5 + numDefine4) | 0;
                r6 = (r6 - r7) | 0;
                r6 = r6 & numDefine15;
                r6 = (r5 + r6) | 0;
                r7 = (r6 + numDefine4) | 0;
                r6 = r6 >> numDefine2;
                heapClassInst.heap32[r6] = r5;
                r5 = r7;
            }
            r6 = r5 >> numDefine2;
            heapClassInst.heap32[r6 + 1] = numDefine53216;
            heapClassInst.heap32[r6 + numDefine2] = numDefine53216;
            r7 = ztv26btTriangleIndexVertexArray;
            heapClassInst.heap32[r6 + numDefine3] = numDefine53216;
            r7 = (r7 + numDefine8) | 0;
            heapClassInst.heap32[r6 + numDefine4] = 0;
            r8 = 1;
            heapClassInst.heap32[r6] = r7;
            heapClassInst.heap8[r5 + numDefine36] = (byte) r8;
            heapClassInst.heap32[r6 + numDefine8] = 0;
            heapClassInst.heap32[r6 + numDefine6] = 0;
            r7 = landscapeVtx;
            r9 = r2 << numDefine2;
            r10 = landscapeVtxCount;
            r11 = landscapeIdx;
            r12 = landscapeIdxCount;
            r7 = (r7 + r9) | 0;
            r10 = (r10 + r9) | 0;
            r11 = (r11 + r9) | 0;
            r9 = (r12 + r9) | 0;
            heapClassInst.heap32[r6 + numDefine7] = 0;
            r7 = r7 >> numDefine2;
            heapClassInst.heap32[r6 + numDefine12] = 0;
            r10 = r10 >> numDefine2;
            r11 = r11 >> numDefine2;
            r9 = r9 >> numDefine2;
            r7 = heapClassInst.heap32[r7];
            r10 = heapClassInst.heap32[r10];
            r11 = heapClassInst.heap32[r11];
            r9 = heapClassInst.heap32[r9];
            r12 = (r4 + numDefine2) | 0;
            heapClassInst.heap32[r3] = r12;
            heapClassInst.heap32[g0] = numDefine51;
            mallocNew(i7);
            r12 = commonVariable.rg0;
            r9 = (r9 / numDefine3) | 0;
            if (r12 != 0) {
                r13 = 0;
                r14 = (r12 + numDefine4) | 0;
                r13 = (r13 - r14) | 0;
                r13 = r13 & numDefine15;
                r13 = (r12 + r13) | 0;
                r14 = (r13 + numDefine4) | 0;
                r13 = r13 >> numDefine2;
                heapClassInst.heap32[r13] = r12;
                r12 = r14;
            }
            heapClassInst.heap8[r5 + numDefine36] = (byte) r8;
            heapClassInst.heap32[r6 + numDefine8] = r12;
            heapClassInst.heap32[r6 + numDefine7] = 1;
            r13 = heapClassInst.heap32[r6 + numDefine6];
            r13 = r13 << numDefine5;
            r12 = (r12 + r13) | 0;
            r12 = r12 >> numDefine2;
            heapClassInst.heap32[r12] = r9;
            heapClassInst.heap32[r12 + 1] = r11;
            heapClassInst.heap32[r12 + numDefine2] = numDefine6;
            heapClassInst.heap32[r12 + numDefine3] = r10;
            heapClassInst.heap32[r12 + numDefine4] = r7;
            heapClassInst.heap32[r12 + numDefine5] = numDefine12;
            heapClassInst.heap32[r12 + numDefine6] = numDefine3;
            heapClassInst.heap32[r12 + numDefine7] = 0;
            r7 = heapClassInst.heap32[r6 + numDefine6];
            r9 = (r7 + 1) | 0;
            heapClassInst.heap32[r6 + numDefine6] = r9;
            r7 = r7 << numDefine5;
            r9 = heapClassInst.heap32[r6 + numDefine8];
            r7 = (r9 + r7) | 0;
            r7 = r7 >> numDefine2;
            r4 = (r4 + numDefine3) | 0;
            heapClassInst.heap32[r7 + numDefine6] = numDefine3;
            heapClassInst.heap32[r3] = r4;
            heapClassInst.heap32[g0] = numDefine95;
            mallocNew(i7);
            r3 = commonVariable.rg0;
            if (r3 != 0) {
                r4 = 0;
                r7 = (r3 + numDefine4) | 0;
                r4 = (r4 - r7) | 0;
                r4 = r4 & numDefine15;
                r4 = (r3 + r4) | 0;
                r7 = (r4 + numDefine4) | 0;
                r4 = r4 >> numDefine2;
                heapClassInst.heap32[r4] = r3;
                r3 = r7;
            }
            r4 = r3 >> numDefine2;
            r7 = ztv19btTriangleMeshShape;
            heapClassInst.heap32[r4 + numDefine2] = 0;
            r7 = (r7 + numDefine8) | 0;
            heapClassInst.heap32[r4 + numDefine3] = 0;
            heapClassInst.heap32[r4] = r7;
            heapClassInst.heap32[r4 + numDefine12] = r5;
            heapClassInst.heap32[r4 + 1] = numDefine21;
            r7 = heapClassInst.heap32[r6];
            r7 = r7 >> numDefine2;
            r7 = heapClassInst.heap32[r7 + numDefine10];
            heapClassInst.heap32[g0] = r5;
            functionTable.get(r7 >> numDefine2).accept(i7);
            r7 = commonVariable.rg0;
            if (r7 == 0) {
                heapClassInst.heap32[g0] = r3;
                zn19btTriangleMeshShape15recalcLocalAabbEv(i7);
            } else {
                r6 = heapClassInst.heap32[r6];
                r6 = r6 >> numDefine2;
                r6 = heapClassInst.heap32[r6 + numDefine12];
                r7 = (r3 + numDefine16) | 0;
                r9 = (r3 + numDefine32) | 0;
                heapClassInst.heap32[g0] = r5;
                heapClassInst.heap32[g0 + 1] = r7;
                heapClassInst.heap32[g0 + numDefine2] = r9;
                functionTable.get(r6 >> numDefine2).accept(i7);
            }
            r5 = ztv22btBvhTriangleMeshShape;
            r5 = (r5 + numDefine8) | 0;
            heapClassInst.heap32[r4] = r5;
            heapClassInst.heap32[r4 + numDefine13] = 0;
            heapClassInst.heap32[r4 + numDefine14] = 0;
            r5 = 0;
            heapClassInst.heap8[r3 + numDefine60] = (byte) r8;
            heapClassInst.heap8[r3 + numDefine61] = (byte) r5;
            heapClassInst.heap32[r4 + 1] = numDefine21;
            heapClassInst.heap32[g0] = r3;
            zn22btBvhTriangleMeshShape17buildOptimizedBvhEv(i7);
            heapClassInst.heap32[r1 + numDefine12] = 0;
            heapClassInst.heap32[r1 + numDefine13] = numDefineNeg57408;
            r4 = zl14benchmarkDemo4;
            heapClassInst.heap32[r1 + numDefine14] = 0;
            r5 = r4 >> numDefine2;
            heapClassInst.heap32[r1 + numDefine15] = 0;
            r5 = heapClassInst.heap32[r5];
            r5 = r5 >> numDefine2;
            r5 = heapClassInst.heap32[r5 + numDefine2];
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = 0;
            heapClassInst.heap32[g0 + numDefine2] = r0;
            heapClassInst.heap32[g0 + numDefine3] = r3;
            functionTable.get(r5 >> numDefine2).accept(i7);
            r2 = (r2 + 1) | 0;
            r3 = commonVariable.rg0 >> numDefine2;
            heapClassInst.heap32[r3 + numDefine56] = numDefine75494;
            if (r2 != numDefine8) {
                continue repeat1;
            } else {
                break repeat1;
            }
        }
        return;
    }

    public static void zn13BenchmarkDemo11createTest6Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        double f5 = 0.0;
        double f6 = 0.0;
        double f7 = 0.0;
        double f8 = 0.0;
        double f9 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg112;
        int g0 = i7 >> numDefine2;
        r0 = gNumAlignedAllocs;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r1 = (r1 + 1) | 0;
        heapClassInst.heap32[r0] = r1;
        heapClassInst.heap32[g0] = numDefine127;
        mallocNew(i7);
        r0 = commonVariable.rg0;
        if (r0 != 0) {
            r1 = 0;
            r2 = (r0 + numDefine4) | 0;
            r1 = (r1 - r2) | 0;
            r1 = r1 & numDefine15;
            r1 = (r0 + r1) | 0;
            r2 = (r1 + numDefine4) | 0;
            r1 = r1 >> numDefine2;
            heapClassInst.heap32[r1] = r0;
            r0 = r2;
        }
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = 0;
        heapClassInst.heap32[g0 + numDefine2] = 0;
        r1 = 0;
        zn17btConvexHullShapeC1EPKfii(i7);
        repeat4:
        while (true) {
            r2 = (r1 * numDefineNeg3) | 0;
            r3 = zl7TaruVtx;
            r2 = r2 << numDefine2;
            r2 = (r3 + r2) | 0;
            r3 = sp + numDefineNeg96;
            r2 = r2 >> numDefine2;
            r4 = r3 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg24] = heapClassInst.heap32[r2];
            heapClassInst.heap32[r4 + 1] = heapClassInst.heap32[r2 + 1];
            heapClassInst.heap32[r4 + numDefine2] = heapClassInst.heap32[r2 + numDefine2];
            heapClassInst.heap32[r4 + numDefine3] = 0;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r3;
            r1 = (r1 + -1) | 0;
            zn17btConvexHullShape8addPointERK9btVector3(i7);
            if (r1 == numDefineNeg43) {
                break repeat4;
            } else {
                continue repeat4;
            }
        }
        r1 = sp + numDefineNeg64;
        r2 = r1 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg16] = numDefine53216;
        heapClassInst.heap32[r2 + 1] = 0;
        heapClassInst.heap32[r2 + numDefine2] = 0;
        heapClassInst.heap32[r2 + numDefine3] = 0;
        heapClassInst.heap32[r2 + numDefine4] = 0;
        heapClassInst.heap32[r2 + numDefine5] = numDefine53216;
        heapClassInst.heap32[r2 + numDefine6] = 0;
        heapClassInst.heap32[r2 + numDefine7] = 0;
        heapClassInst.heap32[r2 + numDefine8] = 0;
        heapClassInst.heap32[r2 + numDefine9] = 0;
        heapClassInst.heap32[r2 + numDefine10] = numDefine53216;
        heapClassInst.heap32[r2 + numDefine11] = 0;
        heapClassInst.heap32[r2 + numDefine12] = 0;
        heapClassInst.heap32[r2 + numDefine13] = 0;
        heapClassInst.heap32[r2 + numDefine14] = 0;
        r3 = sp + numDefineNeg80;
        heapClassInst.heap32[r2 + numDefine15] = 0;
        r4 = r3 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg20] = 0;
        heapClassInst.heap32[r4 + 1] = 0;
        heapClassInst.heap32[r4 + numDefine2] = 0;
        r5 = r0 >> numDefine2;
        heapClassInst.heap32[r4 + numDefine3] = 0;
        r4 = heapClassInst.heap32[r5];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine8];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = numDefine53216;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        r3 = numDefine10;
        f0 = numDefine20;
        f1 = numDefine2;
        f2 = numDefineNeg25;
        functionTable.get(r4 >> numDefine2).accept(i7);
        r7 = zl14benchmarkDemo4;
        repeat7:
        while (true) {
            f3 = numDefine3;
            f4 = numDefine25;
            f5 = f1 + f3;
            f4 = f0 + f4;
            r4 = 0;
            r5 = r4;
            repeat9:
            while (true) {
                f6 = r5;
                f6 = f6 * f5;
                f6 = f6 + f2;
                f7 = numDefine5;
                f6 = f6 * f7;
                f8 = 0;
                f6 = f6 + f8;
                r6 = r4;
                repeat11:
                while (true) {
                    f9 = r6;
                    f9 = f9 * f5;
                    f9 = f9 + f2;
                    f9 = f9 * f7;
                    f9 = f9 + f8;
                    heapClassInst.heapFloat[r2 + numDefine12] = (float) f9;
                    heapClassInst.heapFloat[r2 + numDefine13] = (float) f4;
                    heapClassInst.heapFloat[r2 + numDefine14] = (float) f6;
                    r8 = r7 >> numDefine2;
                    heapClassInst.heap32[r2 + numDefine15] = 0;
                    r8 = heapClassInst.heap32[r8];
                    r8 = r8 >> numDefine2;
                    r8 = heapClassInst.heap32[r8 + numDefine2];
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = numDefine53216;
                    heapClassInst.heap32[g0 + numDefine2] = r1;
                    heapClassInst.heap32[g0 + numDefine3] = r0;
                    r6 = (r6 + 1) | 0;
                    functionTable.get(r8 >> numDefine2).accept(i7);
                    if (r6 != numDefine10) {
                        continue repeat11;
                    } else {
                        break repeat11;
                    }
                }
                r5 = (r5 + 1) | 0;
                if (r5 != numDefine10) {
                    continue repeat9;
                } else {
                    break repeat9;
                }
            }
            f4 = numDefineFloat179;
            f5 = numDefineNegFloat006;
            f4 = f1 * f4;
            f1 = f1 * f5;
            f5 = numDefine9;
            f3 = f4 + f3;
            f1 = f1 * f5;
            r3 = (r3 + -1) | 0;
            f0 = f0 + f3;
            f2 = f1 + f2;
            f1 = f4;
            if (r3 == 0) {
                break repeat7;
            } else {
                continue repeat7;
            }
        }
        zn13BenchmarkDemo19createLargeMeshBodyEv(i7);
        return;
    }

    public static void zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int label = 0;
        i7 = sp + numDefineNeg168;
        int g0 = i7 >> numDefine2;
        r0 = sp + numDefineNeg16;
        r1 = r0 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg4] = 0;
        heapClassInst.heap32[r1 + 1] = 0;
        r2 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[r1 + numDefine2] = 0;
        r3 = r2 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine3] = 0;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine8];
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = numDefine53216;
        heapClassInst.heap32[g0 + numDefine2] = r0;
        r0 = zgvzn11btTransform11getIdentityEvE17identityTransform;
        functionTable.get(r3 >> numDefine2).accept(i7);
        r3 = heapClassInst.heapU8[r0];
        if (!(r3 != 0)) {
            r3 = zgvzn11btMatrix3x311getIdentityEvE14identityMatrix;
            r4 = heapClassInst.heapU8[r3];
            if (!(r4 != 0)) {
                r4 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E02E02E0;
                r5 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E12E02E1;
                r4 = r4 >> numDefine2;
                r6 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E22E02E2;
                r5 = r5 >> numDefine2;
                heapClassInst.heap32[r4] = numDefine53216;
                r4 = r6 >> numDefine2;
                heapClassInst.heap32[r5] = numDefine53216;
                r5 = 1;
                heapClassInst.heap32[r4] = numDefine53216;
                heapClassInst.heap8[r3] = (byte) r5;
            }
            r3 = zzn11btTransform11getIdentityEvE17identityTransform;
            r4 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E02E02E0;
            r3 = r3 >> numDefine2;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r3] = heapClassInst.heap32[r4];
            heapClassInst.heap32[r3 + 1] = 0;
            heapClassInst.heap32[r3 + numDefine2] = 0;
            r4 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E12E02E1;
            heapClassInst.heap32[r3 + numDefine3] = 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r3 + numDefine4] = 0;
            heapClassInst.heap32[r3 + numDefine5] = heapClassInst.heap32[r4];
            heapClassInst.heap32[r3 + numDefine6] = 0;
            heapClassInst.heap32[r3 + numDefine7] = 0;
            r4 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E22E02E2;
            heapClassInst.heap32[r3 + numDefine8] = 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r3 + numDefine9] = 0;
            heapClassInst.heap32[r3 + numDefine10] = heapClassInst.heap32[r4];
            heapClassInst.heap32[r3 + numDefine11] = 0;
            heapClassInst.heap32[r3 + numDefine12] = 0;
            heapClassInst.heap32[r3 + numDefine13] = 0;
            heapClassInst.heap32[r3 + numDefine14] = 0;
            r4 = 1;
            heapClassInst.heap32[r3 + numDefine15] = 0;
            heapClassInst.heap8[r0] = (byte) r4;
        }
        r0 = heapClassInst.heap32[fp];
        r3 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[g0] = numDefine200;
        r4 = ztv20btDefaultMotionState;
        znwj(i7);
        r6 = commonVariable.rg0 >> numDefine2;
        r4 = (r4 + numDefine8) | 0;
        r3 = r3 >> numDefine2;
        heapClassInst.heap32[r6] = r4;
        heapClassInst.heap32[r6 + 1] = heapClassInst.heap32[r3];
        heapClassInst.heap32[r6 + numDefine2] = heapClassInst.heap32[r3 + 1];
        heapClassInst.heap32[r6 + numDefine3] = heapClassInst.heap32[r3 + numDefine3];
        heapClassInst.heap32[r6 + numDefine4] = heapClassInst.heap32[r3 + numDefine4];
        heapClassInst.heap32[r6 + numDefine5] = heapClassInst.heap32[r3 + numDefine5];
        heapClassInst.heap32[r6 + numDefine6] = heapClassInst.heap32[r3 + numDefine6];
        heapClassInst.heap32[r6 + numDefine7] = heapClassInst.heap32[r3 + numDefine7];
        heapClassInst.heap32[r6 + numDefine8] = heapClassInst.heap32[r3 + numDefine8];
        heapClassInst.heap32[r6 + numDefine9] = heapClassInst.heap32[r3 + numDefine9];
        heapClassInst.heap32[r6 + numDefine10] = heapClassInst.heap32[r3 + numDefine9];
        heapClassInst.heap32[r6 + numDefine11] = heapClassInst.heap32[r3 + numDefine10];
        heapClassInst.heap32[r6 + numDefine12] = heapClassInst.heap32[r3 + numDefine11];
        heapClassInst.heap32[r6 + numDefine13] = heapClassInst.heap32[r3 + numDefine12];
        heapClassInst.heap32[r6 + numDefine14] = heapClassInst.heap32[r3 + numDefine13];
        r4 = zzn11btTransform11getIdentityEvE17identityTransform;
        heapClassInst.heap32[r6 + numDefine15] = heapClassInst.heap32[r3 + numDefine14];
        r4 = r4 >> numDefine2;
        heapClassInst.heap32[r6 + numDefine16] = heapClassInst.heap32[r3 + numDefine15];
        heapClassInst.heap32[r6 + numDefine17] = heapClassInst.heap32[r4];
        heapClassInst.heap32[r6 + numDefine18] = heapClassInst.heap32[r4 + 1];
        heapClassInst.heap32[r6 + numDefine19] = heapClassInst.heap32[r4 + numDefine2];
        heapClassInst.heap32[r6 + numDefine20] = heapClassInst.heap32[r4 + numDefine3];
        heapClassInst.heap32[r6 + numDefine21] = heapClassInst.heap32[r4 + numDefine4];
        heapClassInst.heap32[r6 + numDefine22] = heapClassInst.heap32[r4 + numDefine5];
        heapClassInst.heap32[r6 + numDefine23] = heapClassInst.heap32[r4 + numDefine6];
        heapClassInst.heap32[r6 + numDefine24] = heapClassInst.heap32[r4 + numDefine7];
        heapClassInst.heap32[r6 + numDefine25] = heapClassInst.heap32[r4 + numDefine8];
        heapClassInst.heap32[r6 + numDefine26] = heapClassInst.heap32[r4 + numDefine9];
        heapClassInst.heap32[r6 + numDefine27] = heapClassInst.heap32[r4 + numDefine10];
        heapClassInst.heap32[r6 + numDefine28] = heapClassInst.heap32[r4 + numDefine11];
        heapClassInst.heap32[r6 + numDefine29] = heapClassInst.heap32[r4 + numDefine12];
        heapClassInst.heap32[r6 + numDefine30] = heapClassInst.heap32[r4 + numDefine13];
        heapClassInst.heap32[r6 + numDefine31] = heapClassInst.heap32[r4 + numDefine14];
        heapClassInst.heap32[r6 + numDefine32] = heapClassInst.heap32[r4 + numDefine15];
        heapClassInst.heap32[r6 + numDefine33] = heapClassInst.heap32[r3];
        heapClassInst.heap32[r6 + numDefine34] = heapClassInst.heap32[r3 + 1];
        heapClassInst.heap32[r6 + numDefine35] = heapClassInst.heap32[r3 + numDefine2];
        heapClassInst.heap32[r6 + numDefine36] = heapClassInst.heap32[r3 + numDefine3];
        heapClassInst.heap32[r6 + numDefine37] = heapClassInst.heap32[r3 + numDefine4];
        heapClassInst.heap32[r6 + numDefine38] = heapClassInst.heap32[r3 + numDefine5];
        heapClassInst.heap32[r6 + numDefine39] = heapClassInst.heap32[r3 + numDefine6];
        heapClassInst.heap32[r6 + numDefine40] = heapClassInst.heap32[r3 + numDefine7];
        heapClassInst.heap32[r6 + numDefine41] = heapClassInst.heap32[r3 + numDefine8];
        heapClassInst.heap32[r6 + numDefine42] = heapClassInst.heap32[r3 + numDefine9];
        heapClassInst.heap32[r6 + numDefine43] = heapClassInst.heap32[r3 + numDefine10];
        heapClassInst.heap32[r6 + numDefine44] = heapClassInst.heap32[r3 + numDefine11];
        heapClassInst.heap32[r6 + numDefine45] = heapClassInst.heap32[r3 + numDefine12];
        heapClassInst.heap32[r6 + numDefine46] = heapClassInst.heap32[r3 + numDefine13];
        heapClassInst.heap32[r6 + numDefine47] = heapClassInst.heap32[r3 + numDefine14];
        heapClassInst.heap32[r6 + numDefine48] = heapClassInst.heap32[r3 + numDefine15];
        r3 = sp + numDefineNeg152;
        heapClassInst.heap32[r6 + numDefine49] = 0;
        r4 = r3 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg38] = numDefine53216;
        heapClassInst.heap32[r4 + 1] = commonVariable.rg0;
        heapClassInst.heap32[r4 + numDefine18] = r2;
        heapClassInst.heap32[r4 + numDefine19] = heapClassInst.heap32[fp + numDefineNeg4];
        heapClassInst.heap32[r4 + numDefine20] = heapClassInst.heap32[r1 + 1];
        heapClassInst.heap32[r4 + numDefine21] = heapClassInst.heap32[r1 + numDefine2];
        heapClassInst.heap32[r4 + numDefine22] = heapClassInst.heap32[r1 + numDefine3];
        heapClassInst.heap32[r4 + numDefine23] = 0;
        heapClassInst.heap32[r4 + numDefine24] = 0;
        heapClassInst.heap32[r4 + numDefine25] = numDefine64608;
        heapClassInst.heap32[r4 + numDefine26] = 0;
        heapClassInst.heap32[r4 + numDefine27] = numDefine97773;
        r1 = 0;
        heapClassInst.heap32[r4 + numDefine28] = numDefine53216;
        heapClassInst.heap8[sp + numDefineNeg36] = (byte) r1;
        heapClassInst.heap32[r4 + numDefine30] = numDefine93162;
        heapClassInst.heap32[r4 + numDefine31] = numDefine81770;
        heapClassInst.heap32[r4 + numDefine32] = numDefine81770;
        heapClassInst.heap32[r4 + numDefine33] = numDefine81770;
        heapClassInst.heap32[r4 + numDefine2] = numDefine53216;
        heapClassInst.heap32[r4 + numDefine3] = 0;
        heapClassInst.heap32[r4 + numDefine4] = 0;
        heapClassInst.heap32[r4 + numDefine5] = 0;
        heapClassInst.heap32[r4 + numDefine6] = 0;
        heapClassInst.heap32[r4 + numDefine7] = numDefine53216;
        heapClassInst.heap32[r4 + numDefine8] = 0;
        heapClassInst.heap32[r4 + numDefine9] = 0;
        heapClassInst.heap32[r4 + numDefine10] = 0;
        heapClassInst.heap32[r4 + numDefine11] = 0;
        heapClassInst.heap32[r4 + numDefine12] = numDefine53216;
        heapClassInst.heap32[r4 + numDefine13] = 0;
        heapClassInst.heap32[r4 + numDefine14] = 0;
        heapClassInst.heap32[r4 + numDefine15] = 0;
        r2 = gNumAlignedAllocs;
        heapClassInst.heap32[r4 + numDefine16] = 0;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r4 + numDefine17] = 0;
        r4 = heapClassInst.heap32[r2];
        r4 = (r4 + 1) | 0;
        heapClassInst.heap32[r2] = r4;
        heapClassInst.heap32[g0] = numDefine627;
        mallocNew(i7);
        r2 = commonVariable.rg0;
        if (r2 != 0) {
            r4 = (r2 + numDefine4) | 0;
            r1 = (r1 - r4) | 0;
            r1 = r1 & numDefine15;
            r1 = (r2 + r1) | 0;
            r4 = (r1 + numDefine4) | 0;
            r1 = r1 >> numDefine2;
            heapClassInst.heap32[r1] = r2;
            r2 = r4;
        }
        r1 = r2 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine41] = numDefine53216;
        heapClassInst.heap32[r1 + numDefine42] = numDefine53216;
        heapClassInst.heap32[r1 + numDefine43] = numDefine53216;
        heapClassInst.heap32[r1 + numDefine44] = 0;
        heapClassInst.heap32[r1 + numDefine45] = 0;
        heapClassInst.heap32[r1 + numDefine46] = numDefine44395;
        heapClassInst.heap32[r1 + numDefine47] = 0;
        heapClassInst.heap32[r1 + numDefine48] = 0;
        heapClassInst.heap32[r1 + numDefine49] = 0;
        heapClassInst.heap32[r1 + numDefine50] = 0;
        heapClassInst.heap32[r1 + numDefine51] = 1;
        heapClassInst.heap32[r1 + numDefine52] = -1;
        heapClassInst.heap32[r1 + numDefine53] = -1;
        heapClassInst.heap32[r1 + numDefine54] = 1;
        heapClassInst.heap32[r1 + numDefine55] = 0;
        heapClassInst.heap32[r1 + numDefine56] = numDefine64608;
        heapClassInst.heap32[r1 + numDefine57] = 0;
        heapClassInst.heap32[r1 + numDefine58] = 1;
        heapClassInst.heap32[r1 + numDefine59] = 0;
        heapClassInst.heap32[r1 + numDefine60] = numDefine53216;
        heapClassInst.heap32[r1 + numDefine61] = 0;
        heapClassInst.heap32[r1 + numDefine62] = 0;
        heapClassInst.heap32[r1 + numDefine63] = 0;
        heapClassInst.heap32[r1 + 1] = numDefine53216;
        heapClassInst.heap32[r1 + numDefine2] = 0;
        heapClassInst.heap32[r1 + numDefine3] = 0;
        heapClassInst.heap32[r1 + numDefine4] = 0;
        heapClassInst.heap32[r1 + numDefine5] = 0;
        heapClassInst.heap32[r1 + numDefine6] = numDefine53216;
        heapClassInst.heap32[r1 + numDefine7] = 0;
        heapClassInst.heap32[r1 + numDefine8] = 0;
        heapClassInst.heap32[r1 + numDefine9] = 0;
        heapClassInst.heap32[r1 + numDefine10] = 0;
        heapClassInst.heap32[r1 + numDefine11] = numDefine53216;
        heapClassInst.heap32[r1 + numDefine12] = 0;
        heapClassInst.heap32[r1 + numDefine13] = 0;
        heapClassInst.heap32[r1 + numDefine14] = 0;
        r4 = ztv11btRigidBody;
        heapClassInst.heap32[r1 + numDefine15] = 0;
        r4 = (r4 + numDefine8) | 0;
        heapClassInst.heap32[r1 + numDefine16] = 0;
        r5 = 1;
        heapClassInst.heap32[r1] = r4;
        heapClassInst.heap8[r2 + numDefine492] = (byte) r5;
        heapClassInst.heap32[r1 + numDefine122] = 0;
        heapClassInst.heap32[r1 + numDefine120] = 0;
        heapClassInst.heap32[r1 + numDefine121] = 0;
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r3;
        zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE(i7);
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + 1];
        r1 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r1];
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine20];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        functionTable.get(r1 >> numDefine2).accept(i7);
        commonVariable.rg0 = r2;
        return;
    }

    public static void zn13BenchmarkDemo11initPhysicsEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        double f5 = 0.0;
        double f6 = 0.0;
        double f7 = 0.0;
        double f8 = 0.0;
        double f9 = 0.0;
        double f10 = 0.0;
        double f11 = 0.0;
        double f12 = 0.0;
        double f13 = 0.0;
        double f14 = 0.0;
        double f15 = 0.0;
        double f16 = 0.0;
        double f17 = 0.0;
        double f18 = 0.0;
        double f19 = 0.0;
        double f20 = 0.0;
        double f21 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg41432;
        int g0 = i7 >> numDefine2;
        heapClassInst.heap32[g0] = numDefine88;
        znwj(i7);
        r0 = commonVariable.rg0;
        r1 = ztv31btDefaultCollisionConfiguration;
        r2 = gNumAlignedAllocs;
        r3 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r3] = r1;
        r1 = heapClassInst.heap32[r2];
        r3 = (r1 + 1) | 0;
        heapClassInst.heap32[r2] = r3;
        heapClassInst.heap32[g0] = numDefine379;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r4 = 0;
            r5 = (r3 + numDefine4) | 0;
            r4 = (r4 - r5) | 0;
            r4 = r4 & numDefine15;
            r4 = (r3 + r4) | 0;
            r5 = (r4 + numDefine4) | 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = r3;
            r3 = r5;
        }
        r4 = r3 >> numDefine2;
        heapClassInst.heap32[r4 + numDefine77] = numDefine67991;
        r4 = heapClassInst.heapU8[r3 + numDefine332];
        r4 = r4 & numDefine240;
        r5 = r0 >> numDefine2;
        heapClassInst.heap8[r3 + numDefine332] = (byte) r4;
        r4 = (r1 + numDefine2) | 0;
        heapClassInst.heap32[r5 + numDefine8] = r3;
        heapClassInst.heap32[r2] = r4;
        heapClassInst.heap32[g0] = numDefine23;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r4 = 0;
            r6 = (r3 + numDefine4) | 0;
            r4 = (r4 - r6) | 0;
            r4 = r4 & numDefine15;
            r4 = (r3 + r4) | 0;
            r6 = (r4 + numDefine4) | 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = r3;
            r3 = r6;
        }
        r4 = ztv30btGjkEpaPenetrationDepthSolver;
        r6 = r3 >> numDefine2;
        r4 = (r4 + numDefine8) | 0;
        heapClassInst.heap32[r6] = r4;
        r4 = (r1 + numDefine3) | 0;
        heapClassInst.heap32[r5 + numDefine9] = r3;
        heapClassInst.heap32[r2] = r4;
        heapClassInst.heap32[g0] = numDefine43;
        mallocNew(i7);
        r4 = commonVariable.rg0;
        if (r4 != 0) {
            r3 = 0;
            r6 = (r4 + numDefine4) | 0;
            r3 = (r3 - r6) | 0;
            r3 = r3 & numDefine15;
            r3 = (r4 + r3) | 0;
            r6 = r3 >> numDefine2;
            heapClassInst.heap32[r6] = r4;
            r4 = (r3 + numDefine4) | 0;
            r3 = heapClassInst.heap32[r5 + numDefine9];
        }
        r6 = ztvn23btConvexConvexAlgorithm10CreateFuncE;
        r7 = heapClassInst.heap32[r5 + numDefine8];
        r8 = 0;
        r9 = r4 >> numDefine2;
        r6 = (r6 + numDefine8) | 0;
        heapClassInst.heap8[r4 + numDefine4] = (byte) r8;
        heapClassInst.heap32[r9] = r6;
        heapClassInst.heap32[r9 + numDefine4] = 0;
        heapClassInst.heap32[r9 + numDefine5] = numDefine3;
        heapClassInst.heap32[r9 + numDefine3] = r7;
        heapClassInst.heap32[r9 + numDefine2] = r3;
        r3 = (r1 + numDefine4) | 0;
        heapClassInst.heap32[r5 + numDefine10] = r4;
        heapClassInst.heap32[r2] = r3;
        heapClassInst.heap32[g0] = numDefine27;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r4 = (r3 + numDefine4) | 0;
            r4 = (r8 - r4) | 0;
            r4 = r4 & numDefine15;
            r4 = (r3 + r4) | 0;
            r6 = (r4 + numDefine4) | 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = r3;
            r3 = r6;
        }
        r4 = ztvn33btConvexConcaveCollisionAlgorithm10CreateFuncE;
        r6 = r3 >> numDefine2;
        r4 = (r4 + numDefine8) | 0;
        heapClassInst.heap8[r3 + numDefine4] = (byte) r8;
        heapClassInst.heap32[r6] = r4;
        r4 = (r1 + numDefine5) | 0;
        heapClassInst.heap32[r5 + numDefine11] = r3;
        heapClassInst.heap32[r2] = r4;
        heapClassInst.heap32[g0] = numDefine27;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r4 = (r3 + numDefine4) | 0;
            r4 = (r8 - r4) | 0;
            r4 = r4 & numDefine15;
            r4 = (r3 + r4) | 0;
            r6 = (r4 + numDefine4) | 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = r3;
            r3 = r6;
        }
        r4 = ztvn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE;
        r6 = r3 >> numDefine2;
        r4 = (r4 + numDefine8) | 0;
        heapClassInst.heap8[r3 + numDefine4] = (byte) r8;
        heapClassInst.heap32[r6] = r4;
        r4 = (r1 + numDefine6) | 0;
        heapClassInst.heap32[r5 + numDefine12] = r3;
        heapClassInst.heap32[r2] = r4;
        heapClassInst.heap32[g0] = numDefine27;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r4 = (r3 + numDefine4) | 0;
            r4 = (r8 - r4) | 0;
            r4 = r4 & numDefine15;
            r4 = (r3 + r4) | 0;
            r6 = (r4 + numDefine4) | 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = r3;
            r3 = r6;
        }
        r4 = ztvn28btCompoundCollisionAlgorithm10CreateFuncE;
        r6 = r3 >> numDefine2;
        r4 = (r4 + numDefine8) | 0;
        heapClassInst.heap8[r3 + numDefine4] = (byte) r8;
        heapClassInst.heap32[r6] = r4;
        r4 = (r1 + numDefine7) | 0;
        heapClassInst.heap32[r5 + numDefine13] = r3;
        heapClassInst.heap32[r2] = r4;
        heapClassInst.heap32[g0] = numDefine27;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r4 = (r3 + numDefine4) | 0;
            r4 = (r8 - r4) | 0;
            r4 = r4 & numDefine15;
            r4 = (r3 + r4) | 0;
            r6 = (r4 + numDefine4) | 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = r3;
            r3 = r6;
        }
        r4 = ztvn28btCompoundCollisionAlgorithm17SwappedCreateFuncE;
        r6 = r3 >> numDefine2;
        r4 = (r4 + numDefine8) | 0;
        heapClassInst.heap8[r3 + numDefine4] = (byte) r8;
        heapClassInst.heap32[r6] = r4;
        r4 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r5 + numDefine14] = r3;
        heapClassInst.heap32[r2] = r4;
        heapClassInst.heap32[g0] = numDefine27;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r4 = (r3 + numDefine4) | 0;
            r4 = (r8 - r4) | 0;
            r4 = r4 & numDefine15;
            r4 = (r3 + r4) | 0;
            r6 = (r4 + numDefine4) | 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = r3;
            r3 = r6;
        }
        r4 = ztvn16btEmptyAlgorithm10CreateFuncE;
        r6 = r3 >> numDefine2;
        r4 = (r4 + numDefine8) | 0;
        heapClassInst.heap8[r3 + numDefine4] = (byte) r8;
        heapClassInst.heap32[r6] = r4;
        r4 = (r1 + numDefine9) | 0;
        heapClassInst.heap32[r5 + numDefine15] = r3;
        heapClassInst.heap32[r2] = r4;
        heapClassInst.heap32[g0] = numDefine27;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r4 = (r3 + numDefine4) | 0;
            r4 = (r8 - r4) | 0;
            r4 = r4 & numDefine15;
            r4 = (r3 + r4) | 0;
            r6 = (r4 + numDefine4) | 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = r3;
            r3 = r6;
        }
        r4 = ztvn32btSphereSphereCollisionAlgorithm10CreateFuncE;
        r6 = r3 >> numDefine2;
        r4 = (r4 + numDefine8) | 0;
        heapClassInst.heap8[r3 + numDefine4] = (byte) r8;
        heapClassInst.heap32[r6] = r4;
        r4 = (r1 + numDefine10) | 0;
        heapClassInst.heap32[r5 + numDefine16] = r3;
        heapClassInst.heap32[r2] = r4;
        heapClassInst.heap32[g0] = numDefine27;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r4 = (r3 + numDefine4) | 0;
            r4 = (r8 - r4) | 0;
            r4 = r4 & numDefine15;
            r4 = (r3 + r4) | 0;
            r6 = (r4 + numDefine4) | 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = r3;
            r3 = r6;
        }
        r4 = ztvn34btSphereTriangleCollisionAlgorithm10CreateFuncE;
        r6 = r3 >> numDefine2;
        r4 = (r4 + numDefine8) | 0;
        heapClassInst.heap8[r3 + numDefine4] = (byte) r8;
        heapClassInst.heap32[r6] = r4;
        r6 = (r1 + numDefine11) | 0;
        heapClassInst.heap32[r5 + numDefine18] = r3;
        heapClassInst.heap32[r2] = r6;
        heapClassInst.heap32[g0] = numDefine27;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r6 = (r3 + numDefine4) | 0;
            r6 = (r8 - r6) | 0;
            r6 = r6 & numDefine15;
            r6 = (r3 + r6) | 0;
            r7 = (r6 + numDefine4) | 0;
            r6 = r6 >> numDefine2;
            heapClassInst.heap32[r6] = r3;
            r3 = r7;
        }
        r6 = r3 >> numDefine2;
        heapClassInst.heap8[r3 + numDefine4] = (byte) r8;
        heapClassInst.heap32[r6] = r4;
        r4 = 1;
        heapClassInst.heap32[r5 + numDefine19] = r3;
        r6 = (r1 + numDefine12) | 0;
        heapClassInst.heap8[r3 + numDefine4] = (byte) r4;
        heapClassInst.heap32[r2] = r6;
        heapClassInst.heap32[g0] = numDefine27;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r6 = (r3 + numDefine4) | 0;
            r6 = (r8 - r6) | 0;
            r6 = r6 & numDefine15;
            r6 = (r3 + r6) | 0;
            r7 = (r6 + numDefine4) | 0;
            r6 = r6 >> numDefine2;
            heapClassInst.heap32[r6] = r3;
            r3 = r7;
        }
        r6 = ztvn26btBoxBoxCollisionAlgorithm10CreateFuncE;
        r7 = r3 >> numDefine2;
        r6 = (r6 + numDefine8) | 0;
        heapClassInst.heap8[r3 + numDefine4] = (byte) r8;
        heapClassInst.heap32[r7] = r6;
        r6 = (r1 + numDefine13) | 0;
        heapClassInst.heap32[r5 + numDefine17] = r3;
        heapClassInst.heap32[r2] = r6;
        heapClassInst.heap32[g0] = numDefine35;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r6 = (r3 + numDefine4) | 0;
            r6 = (r8 - r6) | 0;
            r6 = r6 & numDefine15;
            r6 = (r3 + r6) | 0;
            r7 = (r6 + numDefine4) | 0;
            r6 = r6 >> numDefine2;
            heapClassInst.heap32[r6] = r3;
            r3 = r7;
        }
        r6 = ztvn31btConvexPlaneCollisionAlgorithm10CreateFuncE;
        r7 = r3 >> numDefine2;
        r6 = (r6 + numDefine8) | 0;
        heapClassInst.heap8[r3 + numDefine4] = (byte) r8;
        heapClassInst.heap32[r7] = r6;
        heapClassInst.heap32[r7 + numDefine2] = 1;
        heapClassInst.heap32[r7 + numDefine3] = 1;
        r7 = (r1 + numDefine14) | 0;
        heapClassInst.heap32[r5 + numDefine21] = r3;
        heapClassInst.heap32[r2] = r7;
        heapClassInst.heap32[g0] = numDefine35;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r7 = (r3 + numDefine4) | 0;
            r7 = (r8 - r7) | 0;
            r7 = r7 & numDefine15;
            r7 = (r3 + r7) | 0;
            r9 = (r7 + numDefine4) | 0;
            r7 = r7 >> numDefine2;
            heapClassInst.heap32[r7] = r3;
            r3 = r9;
        }
        r7 = r3 >> numDefine2;
        heapClassInst.heap8[r3 + numDefine4] = (byte) r8;
        heapClassInst.heap32[r7] = r6;
        heapClassInst.heap32[r7 + numDefine2] = 1;
        heapClassInst.heap32[r7 + numDefine3] = 1;
        heapClassInst.heap32[r5 + numDefine20] = r3;
        heapClassInst.heap8[r3 + numDefine4] = (byte) r4;
        r3 = (r1 + numDefine15) | 0;
        heapClassInst.heap8[r0 + numDefine12] = (byte) r4;
        heapClassInst.heap32[r2] = r3;
        heapClassInst.heap32[g0] = numDefine39;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r6 = (r3 + numDefine4) | 0;
            r6 = (r8 - r6) | 0;
            r6 = r6 & numDefine15;
            r6 = (r3 + r6) | 0;
            r7 = (r6 + numDefine4) | 0;
            r6 = r6 >> numDefine2;
            heapClassInst.heap32[r6] = r3;
            r3 = r7;
        }
        r6 = r3 >> numDefine2;
        heapClassInst.heap32[r6 + 1] = 0;
        heapClassInst.heap32[r6 + numDefine3] = 0;
        heapClassInst.heap8[r3 + numDefine16] = (byte) r8;
        heapClassInst.heap32[r6] = 0;
        r7 = (r1 + numDefine16) | 0;
        heapClassInst.heap32[r6 + numDefine2] = 0;
        heapClassInst.heap32[r2] = r7;
        heapClassInst.heap32[g0] = numDefine19;
        mallocNew(i7);
        r7 = commonVariable.rg0;
        if (r7 != 0) {
            r9 = (r7 + numDefine4) | 0;
            r9 = (r8 - r9) | 0;
            r9 = r9 & numDefine15;
            r9 = (r7 + r9) | 0;
            r10 = (r9 + numDefine4) | 0;
            r9 = r9 >> numDefine2;
            heapClassInst.heap32[r9] = r7;
            r7 = r10;
        }
        heapClassInst.heap32[r6] = r7;
        heapClassInst.heap32[r6 + 1] = 0;
        heapClassInst.heap32[r5 + numDefine2] = r3;
        r3 = (r1 + numDefine17) | 0;
        heapClassInst.heap8[r0 + numDefine20] = (byte) r4;
        heapClassInst.heap32[r2] = r3;
        heapClassInst.heap32[g0] = numDefine39;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r6 = (r3 + numDefine4) | 0;
            r6 = (r8 - r6) | 0;
            r6 = r6 & numDefine15;
            r6 = (r3 + r6) | 0;
            r7 = (r6 + numDefine4) | 0;
            r6 = r6 >> numDefine2;
            heapClassInst.heap32[r6] = r3;
            r3 = r7;
        }
        r6 = r3 >> numDefine2;
        heapClassInst.heap32[r6] = numDefine1140;
        r7 = (r1 + numDefine18) | 0;
        heapClassInst.heap32[r6 + 1] = numDefine4096;
        heapClassInst.heap32[r2] = r7;
        heapClassInst.heap32[g0] = numDefine69459;
        mallocNew(i7);
        r7 = commonVariable.rg0;
        if (r7 != 0) {
            r9 = (r7 + numDefine4) | 0;
            r9 = (r8 - r9) | 0;
            r9 = r9 & numDefine15;
            r9 = (r7 + r9) | 0;
            r10 = (r9 + numDefine4) | 0;
            r9 = r9 >> numDefine2;
            heapClassInst.heap32[r9] = r7;
            r7 = r10;
        }
        heapClassInst.heap32[r6 + numDefine4] = r7;
        r9 = numDefine4095;
        r10 = numDefine1140;
        heapClassInst.heap32[r6 + numDefine3] = r7;
        heapClassInst.heap32[r6 + numDefine2] = numDefine4096;
        r11 = r7;
        repeat55:
        while (true) {
            r7 = r7 >> numDefine2;
            r10 = (r11 + r10) | 0;
            heapClassInst.heap32[r7] = r10;
            r10 = heapClassInst.heap32[r6];
            r7 = (r11 + r10) | 0;
            r9 = (r9 + -1) | 0;
            r11 = r7;
            if (r9 != 0) {
                continue repeat55;
            } else {
                break repeat55;
            }
        }
        r6 = r7 >> numDefine2;
        heapClassInst.heap32[r6] = 0;
        heapClassInst.heap32[r5 + numDefine4] = r3;
        r3 = (r1 + numDefine19) | 0;
        heapClassInst.heap8[r0 + numDefine28] = (byte) r4;
        heapClassInst.heap32[r2] = r3;
        heapClassInst.heap32[g0] = numDefine39;
        mallocNew(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r6 = (r3 + numDefine4) | 0;
            r6 = (r8 - r6) | 0;
            r6 = r6 & numDefine15;
            r6 = (r3 + r6) | 0;
            r7 = (r6 + numDefine4) | 0;
            r6 = r6 >> numDefine2;
            heapClassInst.heap32[r6] = r3;
            r3 = r7;
        }
        r6 = r3 >> numDefine2;
        heapClassInst.heap32[r6] = numDefine80;
        r1 = (r1 + numDefine20) | 0;
        heapClassInst.heap32[r6 + 1] = numDefine4096;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = numDefine27699;
        mallocNew(i7);
        r1 = commonVariable.rg0;
        if (r1 != 0) {
            r7 = (r1 + numDefine4) | 0;
            r7 = (r8 - r7) | 0;
            r7 = r7 & numDefine15;
            r7 = (r1 + r7) | 0;
            r9 = (r7 + numDefine4) | 0;
            r7 = r7 >> numDefine2;
            heapClassInst.heap32[r7] = r1;
            r1 = r9;
        }
        heapClassInst.heap32[r6 + numDefine4] = r1;
        r7 = numDefine4095;
        r9 = numDefine80;
        heapClassInst.heap32[r6 + numDefine3] = r1;
        heapClassInst.heap32[r6 + numDefine2] = numDefine4096;
        r10 = r1;
        repeat64:
        while (true) {
            r1 = r1 >> numDefine2;
            r9 = (r10 + r9) | 0;
            heapClassInst.heap32[r1] = r9;
            r9 = heapClassInst.heap32[r6];
            r1 = (r10 + r9) | 0;
            r7 = (r7 + -1) | 0;
            r10 = r1;
            if (r7 != 0) {
                continue repeat64;
            } else {
                break repeat64;
            }
        }
        r1 = r1 >> numDefine2;
        r6 = zl14benchmarkDemo4;
        heapClassInst.heap32[r1] = 0;
        r1 = r6 >> numDefine2;
        heapClassInst.heap32[r5 + numDefine6] = r3;
        heapClassInst.heap32[r1 + numDefine16] = r0;
        heapClassInst.heap32[g0] = numDefine5388;
        znwj(i7);
        r0 = commonVariable.rg0;
        r3 = ztv21btCollisionDispatcher;
        r5 = heapClassInst.heap32[r1 + numDefine16];
        r3 = (r3 + numDefine8) | 0;
        r7 = r0 >> numDefine2;
        heapClassInst.heap32[r7] = r3;
        heapClassInst.heap32[r7 + 1] = numDefine2;
        heapClassInst.heap8[r0 + numDefine24] = (byte) r4;
        heapClassInst.heap32[r7 + numDefine5] = 0;
        r3 = ztv16btManifoldResult;
        heapClassInst.heap32[r7 + numDefine3] = 0;
        r3 = (r3 + numDefine8) | 0;
        heapClassInst.heap32[r7 + numDefine4] = 0;
        heapClassInst.heap32[r7 + numDefine7] = r3;
        r3 = swriteIndex.zn21btCollisionDispatcher19defaultNearCallbackER16btBroadphasePairRSRK16btDispatcherInfoIndex;
        heapClassInst.heap32[r7 + numDefine1346] = r5;
        heapClassInst.heap32[r7 + numDefine47] = r3;
        r3 = r5 >> numDefine2;
        r9 = heapClassInst.heap32[r3];
        r9 = r9 >> numDefine2;
        r9 = heapClassInst.heap32[r9 + numDefine3];
        heapClassInst.heap32[g0] = r5;
        functionTable.get(r9 >> numDefine2).accept(i7);
        heapClassInst.heap32[r7 + numDefine48] = commonVariable.rg0;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine2];
        heapClassInst.heap32[g0] = r5;
        functionTable.get(r3 >> numDefine2).accept(i7);
        r5 = (r0 + numDefine200) | 0;
        heapClassInst.heap32[r7 + numDefine49] = commonVariable.rg0;
        repeat67:
        while (true) {
            if (r8 > numDefine35) {
                label = numDefine52;
                break repeat67;
            } else {
                r3 = 0;
                repeat70:
                while (true) {
                    if (r3 < numDefine36) {
                        r7 = r0 >> numDefine2;
                        r7 = heapClassInst.heap32[r7 + numDefine1346];
                        r9 = r7 >> numDefine2;
                        r9 = heapClassInst.heap32[r9];
                        r9 = r9 >> numDefine2;
                        r9 = heapClassInst.heap32[r9 + numDefine5];
                        r10 = r3 << numDefine2;
                        heapClassInst.heap32[g0] = r7;
                        heapClassInst.heap32[g0 + 1] = r8;
                        heapClassInst.heap32[g0 + numDefine2] = r3;
                        r7 = (r5 + r10) | 0;
                        r7 = r7 >> numDefine2;
                        functionTable.get(r9 >> numDefine2).accept(i7);
                        r9 = commonVariable.rg0;
                        heapClassInst.heap32[r7] = r9;
                        if (r9 != 0) {
                            r3 = (r3 + 1) | 0;
                        } else {
                            label = numDefine46;
                            break repeat67;
                        }
                    } else {
                        break repeat70;
                    }
                }
                r8 = (r8 + 1) | 0;
                r5 = (r5 + numDefine144) | 0;
                continue repeat67;
            }
        }
        switch (label) {
            case numDefine52:
                heapClassInst.heap32[r1 + numDefine14] = r0;
                heapClassInst.heap32[g0] = numDefine76;
                znwj(i7);
                r0 = commonVariable.rg0;
                heapClassInst.heap32[g0] = r0;
                zn28btHashedOverlappingPairCacheC1Ev(i7);
                r3 = heapClassInst.heap32[r2];
                r5 = (r3 + 1) | 0;
                heapClassInst.heap32[r2] = r5;
                heapClassInst.heap32[g0] = numDefine135;
                mallocNew(i7);
                r7 = commonVariable.rg0;
                if (r7 != 0) {
                    r8 = 0;
                    r9 = (r7 + numDefine4) | 0;
                    r8 = (r8 - r9) | 0;
                    r8 = r8 & numDefine15;
                    r8 = (r7 + r8) | 0;
                    r9 = (r8 + numDefine4) | 0;
                    r8 = r8 >> numDefine2;
                    heapClassInst.heap32[r8] = r7;
                    r7 = r9;
                }
                r8 = ztv20btAxisSweep3InternalItE;
                r9 = r7 >> numDefine2;
                r8 = (r8 + numDefine8) | 0;
                r10 = numDefineNeg2;
                heapClassInst.heap32[r9] = r8;
                r8 = -1;
                heapClassInst.heap16[(r7 + numDefine4) >> 1] = (short) r10;
                heapClassInst.heap16[(r7 + numDefine6) >> 1] = (short) r8;
                heapClassInst.heap32[r9 + numDefine23] = r0;
                r8 = 0;
                heapClassInst.heap32[r9 + numDefine24] = 0;
                heapClassInst.heap8[r7 + numDefine100] = (byte) r8;
                heapClassInst.heap32[r9 + numDefine26] = 0;
                heapClassInst.heap32[r9 + numDefine27] = 0;
                if (r0 == 0) {
                    r5 = (r3 + numDefine2) | 0;
                    heapClassInst.heap32[r2] = r5;
                    heapClassInst.heap32[g0] = numDefine95;
                    mallocNew(i7);
                    r5 = commonVariable.rg0;
                    if (r5 != 0) {
                        r0 = 0;
                        r3 = (r5 + numDefine4) | 0;
                        r0 = (r0 - r3) | 0;
                        r0 = r0 & numDefine15;
                        r0 = (r5 + r0) | 0;
                        r3 = (r0 + numDefine4) | 0;
                        r0 = r0 >> numDefine2;
                        heapClassInst.heap32[r0] = r5;
                        r5 = r3;
                    }
                    heapClassInst.heap32[g0] = r5;
                    zn28btHashedOverlappingPairCacheC1Ev(i7);
                    heapClassInst.heap32[r9 + numDefine23] = r5;
                    heapClassInst.heap8[r7 + numDefine100] = (byte) r4;
                    r5 = heapClassInst.heap32[r2];
                }
                r0 = (r5 + 1) | 0;
                heapClassInst.heap32[r2] = r0;
                heapClassInst.heap32[g0] = numDefine43;
                mallocNew(i7);
                r0 = commonVariable.rg0;
                if (r0 != 0) {
                    r3 = (r0 + numDefine4) | 0;
                    r3 = (r8 - r3) | 0;
                    r3 = r3 & numDefine15;
                    r3 = (r0 + r3) | 0;
                    r10 = (r3 + numDefine4) | 0;
                    r3 = r3 >> numDefine2;
                    heapClassInst.heap32[r3] = r0;
                    r0 = r10;
                }
                r3 = ztv15btNullPairCache;
                r10 = r0 >> numDefine2;
                r3 = (r3 + numDefine8) | 0;
                heapClassInst.heap32[r10] = r3;
                heapClassInst.heap8[r0 + numDefine20] = (byte) r4;
                heapClassInst.heap32[r10 + numDefine4] = 0;
                heapClassInst.heap32[r10 + numDefine2] = 0;
                heapClassInst.heap32[r10 + numDefine3] = 0;
                r3 = (r5 + numDefine2) | 0;
                heapClassInst.heap32[r9 + numDefine28] = r0;
                heapClassInst.heap32[r2] = r3;
                heapClassInst.heap32[g0] = numDefine175;
                mallocNew(i7);
                r10 = commonVariable.rg0;
                if (r10 != 0) {
                    r11 = (r10 + numDefine4) | 0;
                    r11 = (r8 - r11) | 0;
                    r11 = r11 & numDefine15;
                    r11 = (r10 + r11) | 0;
                    r12 = (r11 + numDefine4) | 0;
                    r11 = r11 >> numDefine2;
                    heapClassInst.heap32[r11] = r10;
                    r10 = r12;
                }
                r11 = ztv16btDbvtBroadphase;
                r12 = r10 >> numDefine2;
                r11 = (r11 + numDefine8) | 0;
                heapClassInst.heap32[r12] = r11;
                repeat92:
                while (true) {
                    r11 = (r10 + r8) | 0;
                    r13 = r11 >> numDefine2;
                    heapClassInst.heap8[r11 + numDefine40] = (byte) r4;
                    heapClassInst.heap32[r13 + numDefine9] = 0;
                    heapClassInst.heap32[r13 + numDefine7] = 0;
                    heapClassInst.heap32[r13 + numDefine8] = 0;
                    heapClassInst.heap32[r13 + 1] = 0;
                    heapClassInst.heap32[r13 + numDefine2] = 0;
                    heapClassInst.heap32[r13 + numDefine3] = -1;
                    r8 = (r8 + numDefine40) | 0;
                    heapClassInst.heap32[r13 + numDefine4] = 0;
                    heapClassInst.heap32[r13 + numDefine5] = 0;
                    if (r8 != numDefine80) {
                        continue repeat92;
                    } else {
                        break repeat92;
                    }
                }
                r8 = 0;
                r11 = (r0 == r8) ? 1 : 0;
                heapClassInst.heap8[r10 + numDefine153] = (byte) r8;
                r11 = r11 & 1;
                heapClassInst.heap8[r10 + numDefine154] = (byte) r4;
                heapClassInst.heap8[r10 + numDefine152] = (byte) r11;
                heapClassInst.heap32[r12 + numDefine25] = 0;
                heapClassInst.heap32[r12 + numDefine26] = 0;
                heapClassInst.heap32[r12 + numDefine31] = 0;
                heapClassInst.heap32[r12 + numDefine27] = 1;
                heapClassInst.heap32[r12 + numDefine28] = 0;
                heapClassInst.heap32[r12 + numDefine29] = numDefine10;
                heapClassInst.heap32[r12 + numDefine30] = 1;
                heapClassInst.heap32[r12 + numDefine32] = 0;
                heapClassInst.heap32[r12 + numDefine33] = 0;
                heapClassInst.heap32[r12 + numDefine34] = 0;
                if (r0 == 0) {
                    r0 = (r5 + numDefine3) | 0;
                    heapClassInst.heap32[r2] = r0;
                    heapClassInst.heap32[g0] = numDefine95;
                    mallocNew(i7);
                    r0 = commonVariable.rg0;
                    if (r0 != 0) {
                        r3 = 0;
                        r5 = (r0 + numDefine4) | 0;
                        r3 = (r3 - r5) | 0;
                        r3 = r3 & numDefine15;
                        r3 = (r0 + r3) | 0;
                        r5 = (r3 + numDefine4) | 0;
                        r3 = r3 >> numDefine2;
                        heapClassInst.heap32[r3] = r0;
                        r0 = r5;
                    }
                    heapClassInst.heap32[g0] = r0;
                    zn28btHashedOverlappingPairCacheC1Ev(i7);
                    r3 = heapClassInst.heap32[r2];
                }
                heapClassInst.heap32[r12 + numDefine24] = r0;
                heapClassInst.heap32[r12 + numDefine37] = 0;
                heapClassInst.heap32[r12 + numDefine35] = 0;
                heapClassInst.heap32[r12 + numDefine36] = 0;
                heapClassInst.heap32[r12 + numDefine21] = 0;
                heapClassInst.heap32[r12 + numDefine22] = 0;
                heapClassInst.heap32[r12 + numDefine23] = 0;
                heapClassInst.heap32[r9 + numDefine27] = r10;
                heapClassInst.heap8[r10 + numDefine153] = (byte) r4;
                heapClassInst.heap32[r9 + numDefine2] = numDefineNeg37568;
                heapClassInst.heap32[r9 + numDefine3] = numDefineNeg37568;
                heapClassInst.heap32[r9 + numDefine4] = numDefineNeg37568;
                heapClassInst.heap32[r9 + numDefine5] = 0;
                heapClassInst.heap32[r9 + numDefine6] = numDefine46080;
                heapClassInst.heap32[r9 + numDefine7] = numDefine46080;
                heapClassInst.heap32[r9 + numDefine8] = numDefine46080;
                heapClassInst.heap32[r9 + numDefine9] = 0;
                r0 = heapClassInst.heapU16[(r7 + numDefine6) >> 1];
                f0 = uint(r0);
                f1 = numDefine2000;
                f0 = f0 / f1;
                heapClassInst.heapFloat[r9 + numDefine10] = (float) f0;
                heapClassInst.heapFloat[r9 + numDefine11] = (float) f0;
                heapClassInst.heapFloat[r9 + numDefine12] = (float) f0;
                r0 = (r3 + 1) | 0;
                heapClassInst.heap32[r9 + numDefine13] = 0;
                heapClassInst.heap32[r2] = r0;
                heapClassInst.heap32[g0] = numDefine24083;
                mallocNew(i7);
                r0 = commonVariable.rg0;
                if (r0 != 0) {
                    r5 = (r0 + numDefine4) | 0;
                    r5 = (r8 - r5) | 0;
                    r5 = r5 & numDefine15;
                    r5 = (r0 + r5) | 0;
                    r10 = (r5 + numDefine4) | 0;
                    r5 = r5 >> numDefine2;
                    heapClassInst.heap32[r5] = r0;
                    r0 = r10;
                }
                repeat103:
                while (true) {
                    r5 = r8 << numDefine6;
                    r5 = (r0 - r5) | 0;
                    r5 = r5 >> numDefine2;
                    r8 = (r8 + -1) | 0;
                    heapClassInst.heap32[r5] = 0;
                    heapClassInst.heap32[r5 + numDefine2] = 0;
                    if (r8 != numDefineNeg3501) {
                        continue repeat103;
                    } else {
                        break repeat103;
                    }
                }
                r5 = numDefine3501;
                heapClassInst.heap32[r9 + numDefine15] = r0;
                r8 = 0;
                heapClassInst.heap16[(r7 + numDefine58) >> 1] = (short) r5;
                r5 = numDefineNeg112;
                r10 = numDefine2;
                heapClassInst.heap16[(r7 + numDefine56) >> 1] = (short) r8;
                heapClassInst.heap16[(r7 + numDefine64) >> 1] = (short) r4;
                repeat106:
                while (true) {
                    r0 = (r0 - r5) | 0;
                    heapClassInst.heap16[r0 >> 1] = (short) r10;
                    r5 = (r5 + numDefineNeg64) | 0;
                    r0 = heapClassInst.heap32[r9 + numDefine15];
                    r10 = (r10 + 1) | 0;
                    if (r5 != numDefineNeg24112) {
                        continue repeat106;
                    } else {
                        break repeat106;
                    }
                }
                r3 = (r3 + numDefine2) | 0;
                heapClassInst.heap16[(r0 + numDefine24048) >> 1] = (short) r8;
                repeat109:
                while (true) {
                    r0 = (r3 + r8) | 0;
                    heapClassInst.heap32[r2] = r0;
                    heapClassInst.heap32[g0] = numDefine28027;
                    mallocNew(i7);
                    r0 = commonVariable.rg0;
                    if (r0 != 0) {
                        r5 = 0;
                        r10 = (r0 + numDefine4) | 0;
                        r5 = (r5 - r10) | 0;
                        r5 = r5 & numDefine15;
                        r5 = (r0 + r5) | 0;
                        r10 = (r5 + numDefine4) | 0;
                        r5 = r5 >> numDefine2;
                        heapClassInst.heap32[r5] = r0;
                        r0 = r10;
                    }
                    r5 = r8 << numDefine2;
                    r5 = (r7 + r5) | 0;
                    r5 = r5 >> numDefine2;
                    r8 = (r8 + 1) | 0;
                    heapClassInst.heap32[r5 + numDefine20] = r0;
                    heapClassInst.heap32[r5 + numDefine17] = r0;
                    if (r8 != numDefine3) {
                        continue repeat109;
                    } else {
                        break repeat109;
                    }
                }
                r0 = heapClassInst.heap32[r9 + numDefine15];
                r0 = r0 >> numDefine2;
                heapClassInst.heap32[r0] = 0;
                r0 = heapClassInst.heap32[r9 + numDefine15];
                r3 = 0;
                heapClassInst.heap16[(r0 + numDefine48) >> 1] = (short) r3;
                r0 = heapClassInst.heap32[r9 + numDefine15];
                heapClassInst.heap16[(r0 + numDefine54) >> 1] = (short) r4;
                r0 = heapClassInst.heap32[r9 + numDefine17];
                heapClassInst.heap16[r0 >> 1] = (short) r3;
                r0 = heapClassInst.heap32[r9 + numDefine17];
                heapClassInst.heap16[(r0 + numDefine2) >> 1] = (short) r3;
                r0 = heapClassInst.heap32[r9 + numDefine17];
                r5 = heapClassInst.heapU16[(r7 + numDefine6) >> 1];
                heapClassInst.heap16[(r0 + numDefine4) >> 1] = (short) r5;
                r0 = heapClassInst.heap32[r9 + numDefine17];
                heapClassInst.heap16[(r0 + numDefine6) >> 1] = (short) r3;
                r0 = heapClassInst.heap32[r9 + numDefine15];
                heapClassInst.heap16[(r0 + numDefine50) >> 1] = (short) r3;
                r0 = heapClassInst.heap32[r9 + numDefine15];
                heapClassInst.heap16[(r0 + numDefine56) >> 1] = (short) r4;
                r0 = heapClassInst.heap32[r9 + numDefine18];
                heapClassInst.heap16[r0 >> 1] = (short) r3;
                r0 = heapClassInst.heap32[r9 + numDefine18];
                heapClassInst.heap16[(r0 + numDefine2) >> 1] = (short) r3;
                r0 = heapClassInst.heap32[r9 + numDefine18];
                r5 = heapClassInst.heapU16[(r7 + numDefine6) >> 1];
                heapClassInst.heap16[(r0 + numDefine4) >> 1] = (short) r5;
                r0 = heapClassInst.heap32[r9 + numDefine18];
                heapClassInst.heap16[(r0 + numDefine6) >> 1] = (short) r3;
                r0 = heapClassInst.heap32[r9 + numDefine15];
                heapClassInst.heap16[(r0 + numDefine52) >> 1] = (short) r3;
                r0 = heapClassInst.heap32[r9 + numDefine15];
                heapClassInst.heap16[(r0 + numDefine58) >> 1] = (short) r4;
                r0 = heapClassInst.heap32[r9 + numDefine19];
                heapClassInst.heap16[r0 >> 1] = (short) r3;
                r0 = heapClassInst.heap32[r9 + numDefine19];
                heapClassInst.heap16[(r0 + numDefine2) >> 1] = (short) r3;
                r0 = heapClassInst.heap32[r9 + numDefine19];
                r5 = heapClassInst.heapU16[(r7 + numDefine6) >> 1];
                heapClassInst.heap16[(r0 + numDefine4) >> 1] = (short) r5;
                r0 = heapClassInst.heap32[r9 + numDefine19];
                r5 = ztv12btAxisSweep3;
                r5 = (r5 + numDefine8) | 0;
                heapClassInst.heap16[(r0 + numDefine6) >> 1] = (short) r3;
                heapClassInst.heap32[r9] = r5;
                heapClassInst.heap32[r1 + numDefine13] = r7;
                heapClassInst.heap32[g0] = numDefine128;
                r0 = ztv35btSequentialImpulseConstraintSolver;
                znwj(i7);
                r7 = commonVariable.rg0 >> numDefine2;
                r0 = (r0 + numDefine8) | 0;
                heapClassInst.heap32[r7] = r0;
                heapClassInst.heap8[commonVariable.rg0 + numDefine20] = (byte) r4;
                heapClassInst.heap32[r7 + numDefine4] = 0;
                heapClassInst.heap32[r7 + numDefine2] = 0;
                heapClassInst.heap32[r7 + numDefine3] = 0;
                heapClassInst.heap8[commonVariable.rg0 + numDefine40] = (byte) r4;
                heapClassInst.heap32[r7 + numDefine9] = 0;
                heapClassInst.heap32[r7 + numDefine7] = 0;
                heapClassInst.heap32[r7 + numDefine8] = 0;
                heapClassInst.heap8[commonVariable.rg0 + numDefine60] = (byte) r4;
                heapClassInst.heap32[r7 + numDefine14] = 0;
                heapClassInst.heap32[r7 + numDefine12] = 0;
                heapClassInst.heap32[r7 + numDefine13] = 0;
                heapClassInst.heap8[commonVariable.rg0 + numDefine80] = (byte) r4;
                heapClassInst.heap32[r7 + numDefine19] = 0;
                heapClassInst.heap32[r7 + numDefine17] = 0;
                heapClassInst.heap32[r7 + numDefine18] = 0;
                heapClassInst.heap8[commonVariable.rg0 + numDefine100] = (byte) r4;
                heapClassInst.heap32[r7 + numDefine24] = 0;
                heapClassInst.heap32[r7 + numDefine22] = 0;
                heapClassInst.heap32[r7 + numDefine23] = 0;
                heapClassInst.heap8[commonVariable.rg0 + numDefine120] = (byte) r4;
                heapClassInst.heap32[r7 + numDefine29] = 0;
                heapClassInst.heap32[r7 + numDefine27] = 0;
                heapClassInst.heap32[r7 + numDefine28] = 0;
                heapClassInst.heap32[r7 + numDefine31] = 0;
                heapClassInst.heap32[r1 + numDefine15] = commonVariable.rg0;
                heapClassInst.heap32[g0] = numDefine272;
                znwj(i7);
                r5 = commonVariable.rg0;
                r7 = heapClassInst.heap32[r1 + numDefine16];
                r8 = ztv16btCollisionWorld;
                r9 = heapClassInst.heap32[r1 + numDefine15];
                r10 = heapClassInst.heap32[r1 + numDefine13];
                r11 = heapClassInst.heap32[r1 + numDefine14];
                r8 = (r8 + numDefine8) | 0;
                r12 = r5 >> numDefine2;
                heapClassInst.heap32[r12] = r8;
                heapClassInst.heap8[r5 + numDefine20] = (byte) r4;
                heapClassInst.heap32[r12 + numDefine4] = 0;
                heapClassInst.heap32[r12 + numDefine2] = 0;
                heapClassInst.heap32[r12 + numDefine3] = 0;
                heapClassInst.heap32[r12 + numDefine6] = r11;
                heapClassInst.heap32[r12 + numDefine7] = 0;
                heapClassInst.heap32[r12 + numDefine8] = 0;
                heapClassInst.heap32[r12 + numDefine9] = 1;
                heapClassInst.heap32[r12 + numDefine10] = numDefine53216;
                heapClassInst.heap8[r5 + numDefine44] = (byte) r3;
                heapClassInst.heap32[r12 + numDefine12] = 0;
                heapClassInst.heap8[r5 + numDefine52] = (byte) r3;
                heapClassInst.heap8[r5 + numDefine53] = (byte) r4;
                heapClassInst.heap8[r5 + numDefine54] = (byte) r4;
                heapClassInst.heap32[r12 + numDefine14] = numDefine58986;
                heapClassInst.heap8[r5 + numDefine60] = (byte) r3;
                heapClassInst.heap32[r12 + numDefine16] = 0;
                heapClassInst.heap8[r5 + numDefine68] = (byte) r3;
                heapClassInst.heap32[r12 + numDefine18] = 0;
                heapClassInst.heap32[r12 + numDefine20] = r10;
                heapClassInst.heap32[r12 + numDefine21] = 0;
                r8 = r7 >> numDefine2;
                heapClassInst.heap8[r5 + numDefine88] = (byte) r4;
                r8 = heapClassInst.heap32[r8];
                r8 = r8 >> numDefine2;
                r8 = heapClassInst.heap32[r8 + numDefine4];
                heapClassInst.heap32[g0] = r7;
                functionTable.get(r8 >> numDefine2).accept(i7);
                heapClassInst.heap32[r12 + numDefine19] = commonVariable.rg0;
                heapClassInst.heap32[r12 + numDefine18] = commonVariable.rg0;
                heapClassInst.heap32[r12 + numDefine23] = 0;
                heapClassInst.heap32[r12 + numDefine24] = 0;
                heapClassInst.heap32[r12 + numDefine25] = 0;
                heapClassInst.heap32[r12 + numDefine26] = numDefine42330;
                heapClassInst.heap32[r12 + numDefine27] = numDefine53216;
                heapClassInst.heap32[r12 + numDefine28] = numDefine53722;
                heapClassInst.heap32[r12 + numDefine30] = 0;
                heapClassInst.heap32[r12 + numDefine32] = numDefine04800;
                heapClassInst.heap32[r12 + numDefine31] = numDefine10;
                heapClassInst.heap32[r12 + numDefine34] = numDefine20557;
                heapClassInst.heap32[r12 + numDefine35] = numDefine31949;
                heapClassInst.heap32[r12 + numDefine36] = 0;
                heapClassInst.heap32[r12 + numDefine33] = numDefine53216;
                heapClassInst.heap32[r12 + numDefine37] = 0;
                heapClassInst.heap32[r12 + numDefine38] = numDefineNeg13270;
                heapClassInst.heap32[r12 + numDefine39] = 0;
                heapClassInst.heap32[r12 + numDefine40] = numDefine36634;
                heapClassInst.heap32[r12 + numDefine41] = numDefine260;
                r7 = ztv23btDiscreteDynamicsWorld;
                heapClassInst.heap32[r12 + numDefine42] = numDefine2;
                r7 = (r7 + numDefine8) | 0;
                heapClassInst.heap32[r12 + numDefine43] = numDefine128;
                heapClassInst.heap32[r12] = r7;
                heapClassInst.heap32[r12 + numDefine44] = r9;
                heapClassInst.heap8[r5 + numDefine200] = (byte) r4;
                heapClassInst.heap32[r12 + numDefine49] = 0;
                heapClassInst.heap32[r12 + numDefine47] = 0;
                heapClassInst.heap32[r12 + numDefine48] = 0;
                heapClassInst.heap8[r5 + numDefine220] = (byte) r4;
                heapClassInst.heap32[r12 + numDefine54] = 0;
                heapClassInst.heap32[r12 + numDefine52] = 0;
                heapClassInst.heap32[r12 + numDefine53] = 0;
                heapClassInst.heap32[r12 + numDefine56] = 0;
                heapClassInst.heap32[r12 + numDefine57] = numDefineNeg67456;
                heapClassInst.heap32[r12 + numDefine58] = 0;
                heapClassInst.heap32[r12 + numDefine59] = 0;
                heapClassInst.heap32[r12 + numDefine60] = 0;
                heapClassInst.heap8[r5 + numDefine246] = (byte) r3;
                heapClassInst.heap8[r5 + numDefine264] = (byte) r4;
                heapClassInst.heap32[r12 + numDefine65] = 0;
                heapClassInst.heap32[r12 + numDefine63] = 0;
                heapClassInst.heap32[r12 + numDefine64] = 0;
                heapClassInst.heap32[r12 + numDefine67] = 0;
                if (r9 != 0) {
                    heapClassInst.heap8[r5 + numDefine245] = (byte) r3;
                    r7 = heapClassInst.heap32[r2];
                } else {
                    r7 = heapClassInst.heap32[r2];
                    r7 = (r7 + 1) | 0;
                    heapClassInst.heap32[r2] = r7;
                    heapClassInst.heap32[g0] = numDefine147;
                    mallocNew(i7);
                    r8 = commonVariable.rg0;
                    if (r8 != 0) {
                        r9 = 0;
                        r10 = (r8 + numDefine4) | 0;
                        r9 = (r9 - r10) | 0;
                        r9 = r9 & numDefine15;
                        r9 = (r8 + r9) | 0;
                        r10 = (r9 + numDefine4) | 0;
                        r9 = r9 >> numDefine2;
                        heapClassInst.heap32[r9] = r8;
                        r8 = r10;
                    }
                    r9 = r8 >> numDefine2;
                    heapClassInst.heap32[r9] = r0;
                    heapClassInst.heap8[r8 + numDefine20] = (byte) r4;
                    heapClassInst.heap32[r9 + numDefine4] = 0;
                    heapClassInst.heap32[r9 + numDefine2] = 0;
                    heapClassInst.heap32[r9 + numDefine3] = 0;
                    heapClassInst.heap8[r8 + numDefine40] = (byte) r4;
                    heapClassInst.heap32[r9 + numDefine9] = 0;
                    heapClassInst.heap32[r9 + numDefine7] = 0;
                    heapClassInst.heap32[r9 + numDefine8] = 0;
                    heapClassInst.heap8[r8 + numDefine60] = (byte) r4;
                    heapClassInst.heap32[r9 + numDefine14] = 0;
                    heapClassInst.heap32[r9 + numDefine12] = 0;
                    heapClassInst.heap32[r9 + numDefine13] = 0;
                    heapClassInst.heap8[r8 + numDefine80] = (byte) r4;
                    heapClassInst.heap32[r9 + numDefine19] = 0;
                    heapClassInst.heap32[r9 + numDefine17] = 0;
                    heapClassInst.heap32[r9 + numDefine18] = 0;
                    heapClassInst.heap8[r8 + numDefine100] = (byte) r4;
                    heapClassInst.heap32[r9 + numDefine24] = 0;
                    heapClassInst.heap32[r9 + numDefine22] = 0;
                    heapClassInst.heap32[r9 + numDefine23] = 0;
                    heapClassInst.heap8[r8 + numDefine120] = (byte) r4;
                    heapClassInst.heap32[r9 + numDefine29] = 0;
                    heapClassInst.heap32[r9 + numDefine27] = 0;
                    heapClassInst.heap32[r9 + numDefine28] = 0;
                    r0 = r5 >> numDefine2;
                    heapClassInst.heap32[r9 + numDefine31] = 0;
                    heapClassInst.heap32[r0 + numDefine44] = r8;
                    heapClassInst.heap8[r5 + numDefine245] = (byte) r4;
                }
                r0 = (r7 + 1) | 0;
                heapClassInst.heap32[r2] = r0;
                heapClassInst.heap32[g0] = numDefine87;
                mallocNew(i7);
                r0 = commonVariable.rg0;
                if (r0 != 0) {
                    r7 = (r0 + numDefine4) | 0;
                    r7 = (r3 - r7) | 0;
                    r7 = r7 & numDefine15;
                    r7 = (r0 + r7) | 0;
                    r8 = (r7 + numDefine4) | 0;
                    r7 = r7 >> numDefine2;
                    heapClassInst.heap32[r7] = r0;
                    r0 = r8;
                }
                r7 = ztv25btSimulationIslandManager;
                r8 = r0 >> numDefine2;
                r7 = (r7 + numDefine8) | 0;
                heapClassInst.heap32[r8] = r7;
                heapClassInst.heap8[r0 + numDefine20] = (byte) r4;
                heapClassInst.heap32[r8 + numDefine4] = 0;
                heapClassInst.heap32[r8 + numDefine2] = 0;
                heapClassInst.heap32[r8 + numDefine3] = 0;
                heapClassInst.heap8[r0 + numDefine40] = (byte) r4;
                heapClassInst.heap32[r8 + numDefine9] = 0;
                heapClassInst.heap32[r8 + numDefine7] = 0;
                heapClassInst.heap32[r8 + numDefine8] = 0;
                heapClassInst.heap8[r0 + numDefine60] = (byte) r4;
                heapClassInst.heap32[r8 + numDefine14] = 0;
                heapClassInst.heap32[r8 + numDefine12] = 0;
                heapClassInst.heap32[r8 + numDefine13] = 0;
                r7 = r5 >> numDefine2;
                heapClassInst.heap8[r0 + numDefine64] = (byte) r4;
                heapClassInst.heap32[r7 + numDefine45] = r0;
                heapClassInst.heap8[r5 + numDefine244] = (byte) r4;
                heapClassInst.heap32[r1 + 1] = r5;
                r0 = heapClassInst.heap32[r7 + numDefine41];
                r0 = r0 | numDefine32;
                heapClassInst.heap32[r7 + numDefine41] = r0;
                heapClassInst.heap32[r7 + numDefine31] = numDefine5;
                heapClassInst.heap32[r1 + numDefine2] = 0;
                r0 = heapClassInst.heap32[r1 + 1];
                r5 = r0 >> numDefine2;
                r5 = heapClassInst.heap32[r5];
                r5 = r5 >> numDefine2;
                r5 = heapClassInst.heap32[r5 + numDefine17];
                r7 = sp + numDefineNeg41280;
                r8 = r7 >> numDefine2;
                heapClassInst.heap32[fp + numDefineNeg10320] = 0;
                heapClassInst.heap32[r8 + 1] = numDefineNeg67456;
                heapClassInst.heap32[r8 + numDefine2] = 0;
                heapClassInst.heap32[r8 + numDefine3] = 0;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r7;
                functionTable.get(r5 >> numDefine2).accept(i7);
                r0 = heapClassInst.heap32[r1 + numDefine17];
                if (r0 < numDefine5) {
                    r0 = heapClassInst.heap32[r2];
                    r5 = (r0 + 1) | 0;
                    heapClassInst.heap32[r2] = r5;
                    heapClassInst.heap32[g0] = numDefine71;
                    mallocNew(i7);
                    r5 = commonVariable.rg0;
                    if (r5 != 0) {
                        r7 = 0;
                        r8 = (r5 + numDefine4) | 0;
                        r7 = (r7 - r8) | 0;
                        r7 = r7 & numDefine15;
                        r7 = (r5 + r7) | 0;
                        r8 = (r7 + numDefine4) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heap32[r7] = r5;
                        r5 = r8;
                    }
                    r7 = r5 >> numDefine2;
                    heapClassInst.heap32[r7 + numDefine2] = 0;
                    heapClassInst.heap32[r7 + numDefine3] = numDefine53216;
                    heapClassInst.heap32[r7 + numDefine4] = numDefine53216;
                    heapClassInst.heap32[r7 + numDefine5] = numDefine53216;
                    r8 = ztv10btBoxShape;
                    heapClassInst.heap32[r7 + numDefine6] = 0;
                    r8 = (r8 + numDefine8) | 0;
                    heapClassInst.heap32[r7 + numDefine11] = numDefine58986;
                    heapClassInst.heap32[r7] = r8;
                    heapClassInst.heap32[r7 + 1] = 0;
                    heapClassInst.heap32[r7 + numDefine7] = numDefine66243;
                    heapClassInst.heap32[r7 + numDefine8] = numDefine04362;
                    heapClassInst.heap32[r7 + numDefine9] = numDefine66243;
                    heapClassInst.heap32[r7 + numDefine10] = 0;
                    r7 = heapClassInst.heap32[r1 + numDefine5];
                    r8 = heapClassInst.heap32[r1 + numDefine4];
                    if (r7 == r8) {
                        r9 = r8 << 1;
                        r9 = r8 == 0 ? r4 : r9;
                        if (!(r7 >= r9)) {
                            if (r9 != 0) {
                                r7 = r9 << numDefine2;
                                r0 = (r0 + numDefine2) | 0;
                                r7 = r7 | numDefine3;
                                heapClassInst.heap32[r2] = r0;
                                r0 = (r7 + numDefine16) | 0;
                                heapClassInst.heap32[g0] = r0;
                                mallocNew(i7);
                                r0 = commonVariable.rg0;
                                if (r0 != 0) {
                                    r7 = 0;
                                    r10 = (r0 + numDefine4) | 0;
                                    r7 = (r7 - r10) | 0;
                                    r7 = r7 & numDefine15;
                                    r7 = (r0 + r7) | 0;
                                    r10 = (r7 + numDefine4) | 0;
                                    r7 = r7 >> numDefine2;
                                    heapClassInst.heap32[r7] = r0;
                                    r0 = r10;
                                }
                            } else {
                                r0 = 0;
                            }
                            repeat138:
                            do {
                                if (r8 < 1) {
                                    r10 = heapClassInst.heap32[r1 + numDefine6];
                                } else {
                                    r7 = 0;
                                    while (true) {
                                        r10 = heapClassInst.heap32[r1 + numDefine6];
                                        r11 = r7 << numDefine2;
                                        r12 = (r10 + r11) | 0;
                                        r12 = r12 >> numDefine2;
                                        r11 = (r0 + r11) | 0;
                                        r12 = heapClassInst.heap32[r12];
                                        r7 = (r7 + 1) | 0;
                                        r11 = r11 >> numDefine2;
                                        heapClassInst.heap32[r11] = r12;
                                        if (!(r8 != r7)) {
                                            break repeat138;
                                        }
                                    }
                                }
                            } while (false);
                            if (r10 != 0) {
                                r7 = heapClassInst.heapU8[r6 + numDefine28];
                                if (r7 != 0) {
                                    r8 = gNumAlignedFree;
                                    r8 = r8 >> numDefine2;
                                    r7 = heapClassInst.heap32[r8];
                                    r7 = (r7 + 1) | 0;
                                    r10 = r10 >> numDefine2;
                                    heapClassInst.heap32[r8] = r7;
                                    r8 = heapClassInst.heap32[r10 + -1];
                                    heapClassInst.heap32[g0] = r8;
                                    free(i7);
                                    r8 = heapClassInst.heap32[r1 + numDefine4];
                                }
                                heapClassInst.heap32[r1 + numDefine6] = 0;
                            }
                            heapClassInst.heap8[r6 + numDefine28] = (byte) r4;
                            heapClassInst.heap32[r1 + numDefine6] = r0;
                            heapClassInst.heap32[r1 + numDefine5] = r9;
                        }
                    }
                    r0 = r8 << numDefine2;
                    r7 = heapClassInst.heap32[r1 + numDefine6];
                    r0 = (r7 + r0) | 0;
                    r0 = r0 >> numDefine2;
                    heapClassInst.heap32[r0] = r5;
                    r0 = heapClassInst.heap32[r1 + numDefine4];
                    r0 = (r0 + 1) | 0;
                    r7 = zgvzn11btTransform11getIdentityEvE17identityTransform;
                    heapClassInst.heap32[r1 + numDefine4] = r0;
                    r0 = heapClassInst.heapU8[r7];
                    if (!(r0 != 0)) {
                        r0 = zgvzn11btMatrix3x311getIdentityEvE14identityMatrix;
                        r8 = heapClassInst.heapU8[r0];
                        if (!(r8 != 0)) {
                            r8 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E02E02E0;
                            r9 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E12E02E1;
                            r8 = r8 >> numDefine2;
                            r10 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E22E02E2;
                            r9 = r9 >> numDefine2;
                            heapClassInst.heap32[r8] = numDefine53216;
                            r8 = r10 >> numDefine2;
                            heapClassInst.heap32[r9] = numDefine53216;
                            heapClassInst.heap32[r8] = numDefine53216;
                            heapClassInst.heap8[r0] = (byte) r4;
                        }
                        r0 = zzn11btTransform11getIdentityEvE17identityTransform;
                        r8 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E02E02E0;
                        r0 = r0 >> numDefine2;
                        r8 = r8 >> numDefine2;
                        heapClassInst.heap32[r0] = heapClassInst.heap32[r8];
                        heapClassInst.heap32[r0 + 1] = 0;
                        heapClassInst.heap32[r0 + numDefine2] = 0;
                        r8 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E12E02E1;
                        heapClassInst.heap32[r0 + numDefine3] = 0;
                        r8 = r8 >> numDefine2;
                        heapClassInst.heap32[r0 + numDefine4] = 0;
                        heapClassInst.heap32[r0 + numDefine5] = heapClassInst.heap32[r8];
                        heapClassInst.heap32[r0 + numDefine6] = 0;
                        heapClassInst.heap32[r0 + numDefine7] = 0;
                        r8 = zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E22E02E2;
                        heapClassInst.heap32[r0 + numDefine8] = 0;
                        r8 = r8 >> numDefine2;
                        heapClassInst.heap32[r0 + numDefine9] = 0;
                        heapClassInst.heap32[r0 + numDefine10] = heapClassInst.heap32[r8];
                        heapClassInst.heap32[r0 + numDefine11] = 0;
                        heapClassInst.heap32[r0 + numDefine12] = 0;
                        heapClassInst.heap32[r0 + numDefine13] = 0;
                        heapClassInst.heap32[r0 + numDefine14] = 0;
                        heapClassInst.heap32[r0 + numDefine15] = 0;
                        heapClassInst.heap8[r7] = (byte) r4;
                    }
                    heapClassInst.heap32[g0] = numDefine200;
                    r0 = ztv20btDefaultMotionState;
                    znwj(i7);
                    r8 = commonVariable.rg0 >> numDefine2;
                    r0 = (r0 + numDefine8) | 0;
                    heapClassInst.heap32[r8] = r0;
                    heapClassInst.heap32[r8 + 1] = numDefine53216;
                    heapClassInst.heap32[r8 + numDefine2] = 0;
                    heapClassInst.heap32[r8 + numDefine3] = 0;
                    heapClassInst.heap32[r8 + numDefine4] = 0;
                    heapClassInst.heap32[r8 + numDefine5] = 0;
                    heapClassInst.heap32[r8 + numDefine6] = numDefine53216;
                    heapClassInst.heap32[r8 + numDefine7] = 0;
                    heapClassInst.heap32[r8 + numDefine8] = 0;
                    heapClassInst.heap32[r8 + numDefine9] = 0;
                    heapClassInst.heap32[r8 + numDefine10] = 0;
                    heapClassInst.heap32[r8 + numDefine11] = numDefine53216;
                    heapClassInst.heap32[r8 + numDefine12] = 0;
                    heapClassInst.heap32[r8 + numDefine13] = 0;
                    heapClassInst.heap32[r8 + numDefine14] = numDefineNeg68800;
                    r0 = zzn11btTransform11getIdentityEvE17identityTransform;
                    heapClassInst.heap32[r8 + numDefine15] = 0;
                    r0 = r0 >> numDefine2;
                    heapClassInst.heap32[r8 + numDefine16] = 0;
                    heapClassInst.heap32[r8 + numDefine17] = heapClassInst.heap32[r0];
                    heapClassInst.heap32[r8 + numDefine18] = heapClassInst.heap32[r0 + 1];
                    heapClassInst.heap32[r8 + numDefine19] = heapClassInst.heap32[r0 + numDefine2];
                    heapClassInst.heap32[r8 + numDefine20] = heapClassInst.heap32[r0 + numDefine3];
                    heapClassInst.heap32[r8 + numDefine21] = heapClassInst.heap32[r0 + numDefine4];
                    heapClassInst.heap32[r8 + numDefine22] = heapClassInst.heap32[r0 + numDefine5];
                    heapClassInst.heap32[r8 + numDefine23] = heapClassInst.heap32[r0 + numDefine6];
                    heapClassInst.heap32[r8 + numDefine24] = heapClassInst.heap32[r0 + numDefine7];
                    heapClassInst.heap32[r8 + numDefine25] = heapClassInst.heap32[r0 + numDefine8];
                    heapClassInst.heap32[r8 + numDefine26] = heapClassInst.heap32[r0 + numDefine9];
                    heapClassInst.heap32[r8 + numDefine27] = heapClassInst.heap32[r0 + numDefine10];
                    heapClassInst.heap32[r8 + numDefine28] = heapClassInst.heap32[r0 + numDefine11];
                    heapClassInst.heap32[r8 + numDefine29] = heapClassInst.heap32[r0 + numDefine12];
                    heapClassInst.heap32[r8 + numDefine30] = heapClassInst.heap32[r0 + numDefine13];
                    heapClassInst.heap32[r8 + numDefine31] = heapClassInst.heap32[r0 + numDefine14];
                    heapClassInst.heap32[r8 + numDefine32] = heapClassInst.heap32[r0 + numDefine15];
                    heapClassInst.heap32[r8 + numDefine33] = numDefine53216;
                    heapClassInst.heap32[r8 + numDefine34] = 0;
                    heapClassInst.heap32[r8 + numDefine35] = 0;
                    heapClassInst.heap32[r8 + numDefine36] = 0;
                    heapClassInst.heap32[r8 + numDefine37] = 0;
                    heapClassInst.heap32[r8 + numDefine38] = numDefine53216;
                    heapClassInst.heap32[r8 + numDefine39] = 0;
                    heapClassInst.heap32[r8 + numDefine40] = 0;
                    heapClassInst.heap32[r8 + numDefine41] = 0;
                    heapClassInst.heap32[r8 + numDefine42] = 0;
                    heapClassInst.heap32[r8 + numDefine43] = numDefine53216;
                    heapClassInst.heap32[r8 + numDefine44] = 0;
                    heapClassInst.heap32[r8 + numDefine45] = 0;
                    heapClassInst.heap32[r8 + numDefine46] = numDefineNeg68800;
                    heapClassInst.heap32[r8 + numDefine47] = 0;
                    heapClassInst.heap32[r8 + numDefine48] = 0;
                    r0 = sp + numDefineNeg41416;
                    heapClassInst.heap32[r8 + numDefine49] = 0;
                    r8 = r0 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg10354] = 0;
                    heapClassInst.heap32[r8 + 1] = commonVariable.rg0;
                    heapClassInst.heap32[r8 + numDefine18] = r5;
                    heapClassInst.heap32[r8 + numDefine19] = 0;
                    heapClassInst.heap32[r8 + numDefine20] = 0;
                    heapClassInst.heap32[r8 + numDefine21] = 0;
                    heapClassInst.heap32[r8 + numDefine22] = 0;
                    heapClassInst.heap32[r8 + numDefine23] = 0;
                    heapClassInst.heap32[r8 + numDefine24] = 0;
                    heapClassInst.heap32[r8 + numDefine25] = numDefine64608;
                    heapClassInst.heap32[r8 + numDefine26] = 0;
                    heapClassInst.heap32[r8 + numDefine27] = numDefine97773;
                    r5 = 0;
                    heapClassInst.heap32[r8 + numDefine28] = numDefine53216;
                    heapClassInst.heap8[sp + numDefineNeg41300] = (byte) r5;
                    heapClassInst.heap32[r8 + numDefine30] = numDefine93162;
                    heapClassInst.heap32[r8 + numDefine31] = numDefine81770;
                    heapClassInst.heap32[r8 + numDefine32] = numDefine81770;
                    heapClassInst.heap32[r8 + numDefine33] = numDefine81770;
                    heapClassInst.heap32[r8 + numDefine2] = numDefine53216;
                    heapClassInst.heap32[r8 + numDefine3] = 0;
                    heapClassInst.heap32[r8 + numDefine4] = 0;
                    heapClassInst.heap32[r8 + numDefine5] = 0;
                    heapClassInst.heap32[r8 + numDefine6] = 0;
                    heapClassInst.heap32[r8 + numDefine7] = numDefine53216;
                    heapClassInst.heap32[r8 + numDefine8] = 0;
                    heapClassInst.heap32[r8 + numDefine9] = 0;
                    heapClassInst.heap32[r8 + numDefine10] = 0;
                    heapClassInst.heap32[r8 + numDefine11] = 0;
                    heapClassInst.heap32[r8 + numDefine12] = numDefine53216;
                    heapClassInst.heap32[r8 + numDefine13] = 0;
                    heapClassInst.heap32[r8 + numDefine14] = 0;
                    heapClassInst.heap32[r8 + numDefine15] = 0;
                    heapClassInst.heap32[r8 + numDefine16] = 0;
                    heapClassInst.heap32[r8 + numDefine17] = 0;
                    r7 = heapClassInst.heap32[r2];
                    r7 = (r7 + 1) | 0;
                    heapClassInst.heap32[r2] = r7;
                    heapClassInst.heap32[g0] = numDefine627;
                    mallocNew(i7);
                    r7 = commonVariable.rg0;
                    if (r7 != 0) {
                        r8 = (r7 + numDefine4) | 0;
                        r5 = (r5 - r8) | 0;
                        r5 = r5 & numDefine15;
                        r5 = (r7 + r5) | 0;
                        r8 = (r5 + numDefine4) | 0;
                        r5 = r5 >> numDefine2;
                        heapClassInst.heap32[r5] = r7;
                        r7 = r8;
                    }
                    r5 = r7 >> numDefine2;
                    heapClassInst.heap32[r5 + numDefine41] = numDefine53216;
                    heapClassInst.heap32[r5 + numDefine42] = numDefine53216;
                    heapClassInst.heap32[r5 + numDefine43] = numDefine53216;
                    heapClassInst.heap32[r5 + numDefine44] = 0;
                    heapClassInst.heap32[r5 + numDefine45] = 0;
                    heapClassInst.heap32[r5 + numDefine46] = numDefine44395;
                    heapClassInst.heap32[r5 + numDefine47] = 0;
                    heapClassInst.heap32[r5 + numDefine48] = 0;
                    heapClassInst.heap32[r5 + numDefine49] = 0;
                    heapClassInst.heap32[r5 + numDefine50] = 0;
                    heapClassInst.heap32[r5 + numDefine51] = 1;
                    heapClassInst.heap32[r5 + numDefine52] = -1;
                    heapClassInst.heap32[r5 + numDefine53] = -1;
                    heapClassInst.heap32[r5 + numDefine54] = 1;
                    heapClassInst.heap32[r5 + numDefine55] = 0;
                    heapClassInst.heap32[r5 + numDefine56] = numDefine64608;
                    heapClassInst.heap32[r5 + numDefine57] = 0;
                    heapClassInst.heap32[r5 + numDefine58] = 1;
                    heapClassInst.heap32[r5 + numDefine59] = 0;
                    heapClassInst.heap32[r5 + numDefine60] = numDefine53216;
                    heapClassInst.heap32[r5 + numDefine61] = 0;
                    heapClassInst.heap32[r5 + numDefine62] = 0;
                    heapClassInst.heap32[r5 + numDefine63] = 0;
                    heapClassInst.heap32[r5 + 1] = numDefine53216;
                    heapClassInst.heap32[r5 + numDefine2] = 0;
                    heapClassInst.heap32[r5 + numDefine3] = 0;
                    heapClassInst.heap32[r5 + numDefine4] = 0;
                    heapClassInst.heap32[r5 + numDefine5] = 0;
                    heapClassInst.heap32[r5 + numDefine6] = numDefine53216;
                    heapClassInst.heap32[r5 + numDefine7] = 0;
                    heapClassInst.heap32[r5 + numDefine8] = 0;
                    heapClassInst.heap32[r5 + numDefine9] = 0;
                    heapClassInst.heap32[r5 + numDefine10] = 0;
                    heapClassInst.heap32[r5 + numDefine11] = numDefine53216;
                    heapClassInst.heap32[r5 + numDefine12] = 0;
                    heapClassInst.heap32[r5 + numDefine13] = 0;
                    heapClassInst.heap32[r5 + numDefine14] = 0;
                    r8 = ztv11btRigidBody;
                    heapClassInst.heap32[r5 + numDefine15] = 0;
                    r8 = (r8 + numDefine8) | 0;
                    heapClassInst.heap32[r5 + numDefine16] = 0;
                    heapClassInst.heap32[r5] = r8;
                    heapClassInst.heap8[r7 + numDefine492] = (byte) r4;
                    heapClassInst.heap32[r5 + numDefine122] = 0;
                    heapClassInst.heap32[r5 + numDefine120] = 0;
                    heapClassInst.heap32[r5 + numDefine121] = 0;
                    heapClassInst.heap32[g0] = r7;
                    heapClassInst.heap32[g0 + 1] = r0;
                    zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE(i7);
                    r0 = heapClassInst.heap32[r1 + 1];
                    r5 = r0 >> numDefine2;
                    r5 = heapClassInst.heap32[r5];
                    r5 = r5 >> numDefine2;
                    r5 = heapClassInst.heap32[r5 + numDefine20];
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r7;
                    functionTable.get(r5 >> numDefine2).accept(i7);
                    r0 = heapClassInst.heap32[r1 + numDefine17];
                }
                repeat161:
                do {
                    if (r0 > numDefine3) {
                        if (r0 > numDefine5) {
                            if (r0 == numDefine6) {
                                zn13BenchmarkDemo11createTest6Ev(i7);
                                return;
                            } else {
                                if (r0 == numDefine7) {
                                    zn13BenchmarkDemo11createTest6Ev(i7);
                                    r0 = sp + numDefineNeg41264;
                                    heapClassInst.heap32[g0] = numDefine8;
                                    r1 = r0 >> numDefine2;
                                    znwj(i7);
                                    heapClassInst.heap32[r1 + numDefine10006] = commonVariable.rg0;
                                    heapClassInst.heap32[g0] = commonVariable.rg0;
                                    heapClassInst.heap32[g0 + 1] = 0;
                                    getTimeOfDay(i7);
                                    heapClassInst.heap32[r1 + numDefine10000] = 0;
                                    heapClassInst.heap32[r1 + numDefine10001] = 0;
                                    heapClassInst.heap32[r1 + numDefine10005] = 0;
                                    heapClassInst.heap32[r1 + numDefine10004] = numDefine9999;
                                    heapClassInst.heap32[r1 + numDefine10003] = 0;
                                    heapClassInst.heap32[r1 + numDefine10002] = 0;
                                    heapClassInst.heap32[r1 + numDefine10007] = numDefine16192;
                                    heapClassInst.heap32[r1 + numDefine10008] = 0;
                                    heapClassInst.heap32[r1 + numDefine10009] = 0;
                                    heapClassInst.heap32[r1 + numDefine10010] = numDefine14848;
                                    heapClassInst.heap32[r1 + numDefine10011] = numDefine53216;
                                    f3 = 0;
                                    repeat169:
                                    while (true) {
                                        f0 = r3;
                                        f1 = numDefineFloat074;
                                        f0 = f0 * f1;
                                        f1 = numDefineFloat05;
                                        f0 = f0 * f1;
                                        heapClassInst.heapFloat[g0] = (float) f0;
                                        sinf(i7);
                                        f2 = 1;
                                        f1 = commonVariable.fg0 / f2;
                                        f2 = f1 * f3;
                                        heapClassInst.heapFloat[g0] = (float) f0;
                                        cosf(i7);
                                        f4 = -f2;
                                        f5 = commonVariable.fg0 * f3;
                                        f6 = f2 * f3;
                                        f7 = f4 - f2;
                                        f8 = commonVariable.fg0 + f2;
                                        f8 = f8 - f6;
                                        f7 = f7 - f6;
                                        f9 = f5 + f2;
                                        f9 = f9 - f6;
                                        f5 = f5 + f6;
                                        f6 = f7 * f4;
                                        f10 = f8 * commonVariable.fg0;
                                        f5 = f5 - f1;
                                        f11 = f9 * commonVariable.fg0;
                                        f7 = f7 * f1;
                                        f10 = f6 + f10;
                                        f4 = f9 * f4;
                                        r2 = r3 << numDefine4;
                                        f0 = f5 * commonVariable.fg0;
                                        f7 = f11 - f7;
                                        f9 = f5 * f2;
                                        f10 = f10 + f4;
                                        f5 = f5 * f1;
                                        r2 = (r0 + r2) | 0;
                                        f0 = f6 + f0;
                                        f1 = f8 * f1;
                                        f6 = f7 - f9;
                                        f2 = f8 * f2;
                                        f5 = f10 + f5;
                                        f7 = numDefine2500;
                                        f0 = f0 - f1;
                                        f1 = f6 + f2;
                                        r2 = r2 >> numDefine2;
                                        f2 = f5 * f7;
                                        f0 = f0 - f4;
                                        f1 = f1 * f7;
                                        heapClassInst.heapFloat[r2 + numDefine4000] = (float) f2;
                                        f0 = f0 * f7;
                                        heapClassInst.heapFloat[r2 + numDefine4001] = (float) f1;
                                        heapClassInst.heapFloat[r2 + numDefine4002] = (float) f0;
                                        heapClassInst.heap32[r2 + numDefine4003] = 0;
                                        f1 = heapClassInst.heapFloat[r1 + numDefine10008];
                                        heapClassInst.heapFloat[r2] = (float) f1;
                                        heapClassInst.heap32[r2 + 1] = numDefine14848;
                                        heapClassInst.heap32[r2 + numDefine2] = 0;
                                        f1 = f1 + f2;
                                        heapClassInst.heap32[r2 + numDefine3] = 0;
                                        f0 = f0 + f3;
                                        heapClassInst.heapFloat[r2 + numDefine2000] = (float) f1;
                                        heapClassInst.heapFloat[r2 + numDefine2002] = (float) f0;
                                        heapClassInst.heap32[r2 + numDefine2003] = 0;
                                        heapClassInst.heap32[r2 + numDefine2001] = numDefineNeg37568;
                                        heapClassInst.heap32[r2 + numDefine8000] = numDefine53216;
                                        heapClassInst.heap32[r2 + numDefine8001] = 0;
                                        r3 = (r3 + 1) | 0;
                                        heapClassInst.heap32[r2 + numDefine8002] = 0;
                                        heapClassInst.heap32[r2 + numDefine8003] = 0;
                                        if (!(r3 != numDefine500)) {
                                            break repeat169;
                                        }
                                    }
                                    r2 = zl10raycastBar;
                                    heapClassInst.heap32[g0] = r2;
                                    heapClassInst.heap32[g0 + 1] = r0;
                                    heapClassInst.heap32[g0 + numDefine2] = numDefine8000;
                                    memcpy(i7);
                                    r3 = (r2 + numDefine8000) | 0;
                                    r4 = (r0 + numDefine8000) | 0;
                                    heapClassInst.heap32[g0] = r3;
                                    heapClassInst.heap32[g0 + 1] = r4;
                                    heapClassInst.heap32[g0 + numDefine2] = numDefine8000;
                                    memcpy(i7);
                                    r3 = (r2 + numDefine16000) | 0;
                                    r4 = (r0 + numDefine16000) | 0;
                                    heapClassInst.heap32[g0] = r3;
                                    heapClassInst.heap32[g0 + 1] = r4;
                                    heapClassInst.heap32[g0 + numDefine2] = numDefine8000;
                                    memcpy(i7);
                                    r3 = (r2 + numDefine24000) | 0;
                                    r4 = (r0 + numDefine24000) | 0;
                                    heapClassInst.heap32[g0] = r3;
                                    heapClassInst.heap32[g0 + 1] = r4;
                                    heapClassInst.heap32[g0 + numDefine2] = numDefine8000;
                                    memcpy(i7);
                                    r3 = (r2 + numDefine32000) | 0;
                                    r0 = (r0 + numDefine32000) | 0;
                                    heapClassInst.heap32[g0] = r3;
                                    heapClassInst.heap32[g0 + 1] = r0;
                                    heapClassInst.heap32[g0 + numDefine2] = numDefine8000;
                                    memcpy(i7);
                                    r0 = r2 >> numDefine2;
                                    r2 = heapClassInst.heap32[r1 + numDefine10000];
                                    heapClassInst.heap32[r0 + numDefine10000] = r2;
                                    r2 = heapClassInst.heap32[r1 + numDefine10001];
                                    heapClassInst.heap32[r0 + numDefine10001] = r2;
                                    r2 = heapClassInst.heap32[r1 + numDefine10002];
                                    heapClassInst.heap32[r0 + numDefine10002] = r2;
                                    r2 = heapClassInst.heap32[r1 + numDefine10003];
                                    heapClassInst.heap32[r0 + numDefine10003] = r2;
                                    r2 = heapClassInst.heap32[r1 + numDefine10004];
                                    heapClassInst.heap32[r0 + numDefine10004] = r2;
                                    r2 = heapClassInst.heap32[r1 + numDefine10005];
                                    heapClassInst.heap32[r0 + numDefine10005] = r2;
                                    r2 = heapClassInst.heap32[r1 + numDefine10006];
                                    r2 = r2 >> numDefine2;
                                    r3 = heapClassInst.heap32[r0 + numDefine10006];
                                    r4 = heapClassInst.heap32[r2 + 1];
                                    r2 = heapClassInst.heap32[r2];
                                    r3 = r3 >> numDefine2;
                                    heapClassInst.heap32[r3] = r2;
                                    heapClassInst.heap32[r3 + 1] = r4;
                                    heapClassInst.heap32[r0 + numDefine10007] = heapClassInst.heap32[r1 + numDefine10007];
                                    heapClassInst.heap32[r0 + numDefine10008] = heapClassInst.heap32[r1 + numDefine10008];
                                    heapClassInst.heap32[r0 + numDefine10009] = heapClassInst.heap32[r1 + numDefine10009];
                                    heapClassInst.heap32[r0 + numDefine10010] = heapClassInst.heap32[r1 + numDefine10010];
                                    heapClassInst.heap32[r0 + numDefine10011] = heapClassInst.heap32[r1 + numDefine10011];
                                    r0 = heapClassInst.heap32[r1 + numDefine10006];
                                    heapClassInst.heap32[g0] = r0;
                                    zdlPv(i7);
                                    return;
                                } else {
                                    break repeat161;
                                }
                            }
                        } else {
                            if (r0 == numDefine4) {
                                r3 = heapClassInst.heap32[r2];
                                r3 = (r3 + 1) | 0;
                                heapClassInst.heap32[r2] = r3;
                                heapClassInst.heap32[g0] = numDefine127;
                                mallocNew(i7);
                                r2 = commonVariable.rg0;
                                if (r2 != 0) {
                                    r3 = 0;
                                    r4 = (r2 + numDefine4) | 0;
                                    r3 = (r3 - r4) | 0;
                                    r3 = r3 & numDefine15;
                                    r3 = (r2 + r3) | 0;
                                    r4 = (r3 + numDefine4) | 0;
                                    r3 = r3 >> numDefine2;
                                    heapClassInst.heap32[r3] = r2;
                                    r2 = r4;
                                }
                                heapClassInst.heap32[g0] = r2;
                                heapClassInst.heap32[g0 + 1] = 0;
                                heapClassInst.heap32[g0 + numDefine2] = 0;
                                r3 = r2 >> numDefine2;
                                zn17btConvexHullShapeC1EPKfii(i7);
                                r4 = heapClassInst.heap32[r3];
                                r4 = r4 >> numDefine2;
                                r4 = heapClassInst.heap32[r4 + numDefine6];
                                r0 = sp + numDefineNeg96;
                                r5 = r0 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg24] = numDefine53216;
                                heapClassInst.heap32[r5 + 1] = numDefine53216;
                                heapClassInst.heap32[r5 + numDefine2] = numDefine53216;
                                heapClassInst.heap32[r5 + numDefine3] = 0;
                                heapClassInst.heap32[g0] = r2;
                                heapClassInst.heap32[g0 + 1] = r0;
                                r0 = 0;
                                functionTable.get(r4 >> numDefine2).accept(i7);
                                repeat178:
                                while (true) {
                                    r4 = (r0 * numDefineNeg3) | 0;
                                    r5 = zl7TaruVtx;
                                    r4 = r4 << numDefine2;
                                    r4 = (r5 + r4) | 0;
                                    r5 = sp + numDefineNeg80;
                                    r4 = r4 >> numDefine2;
                                    r7 = r5 >> numDefine2;
                                    heapClassInst.heap32[fp + numDefineNeg20] = heapClassInst.heap32[r4];
                                    heapClassInst.heap32[r7 + 1] = heapClassInst.heap32[r4 + 1];
                                    heapClassInst.heap32[r7 + numDefine2] = heapClassInst.heap32[r4 + numDefine2];
                                    heapClassInst.heap32[r7 + numDefine3] = 0;
                                    heapClassInst.heap32[g0] = r2;
                                    heapClassInst.heap32[g0 + 1] = r5;
                                    r0 = (r0 + -1) | 0;
                                    zn17btConvexHullShape8addPointERK9btVector3(i7);
                                    if (r0 == numDefineNeg43) {
                                        break repeat178;
                                    }
                                }
                                r4 = sp + numDefineNeg160;
                                r0 = r4 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg40] = numDefine53216;
                                heapClassInst.heap32[r0 + 1] = 0;
                                heapClassInst.heap32[r0 + numDefine2] = 0;
                                heapClassInst.heap32[r0 + numDefine3] = 0;
                                heapClassInst.heap32[r0 + numDefine4] = 0;
                                heapClassInst.heap32[r0 + numDefine5] = numDefine53216;
                                heapClassInst.heap32[r0 + numDefine6] = 0;
                                heapClassInst.heap32[r0 + numDefine7] = 0;
                                heapClassInst.heap32[r0 + numDefine8] = 0;
                                heapClassInst.heap32[r0 + numDefine9] = 0;
                                heapClassInst.heap32[r0 + numDefine10] = numDefine53216;
                                heapClassInst.heap32[r0 + numDefine11] = 0;
                                heapClassInst.heap32[r0 + numDefine12] = 0;
                                heapClassInst.heap32[r0 + numDefine13] = 0;
                                heapClassInst.heap32[r0 + numDefine14] = 0;
                                r5 = sp + numDefineNeg176;
                                heapClassInst.heap32[r0 + numDefine15] = 0;
                                r7 = r5 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg44] = 0;
                                heapClassInst.heap32[r7 + 1] = 0;
                                heapClassInst.heap32[r7 + numDefine2] = 0;
                                heapClassInst.heap32[r7 + numDefine3] = 0;
                                r3 = heapClassInst.heap32[r3];
                                r3 = r3 >> numDefine2;
                                r7 = heapClassInst.heap32[r3 + numDefine8];
                                heapClassInst.heap32[g0] = r2;
                                heapClassInst.heap32[g0 + 1] = numDefine53216;
                                heapClassInst.heap32[g0 + numDefine2] = r5;
                                r3 = numDefine15;
                                f0 = numDefine3;
                                f2 = numDefineNeg18;
                                f3 = numDefineFloat15;
                                functionTable.get(r7 >> numDefine2).accept(i7);
                                f1 = f0;
                                repeat181:
                                while (true) {
                                    f4 = f3 + f0;
                                    r5 = 0;
                                    r7 = r5;
                                    repeat183:
                                    while (true) {
                                        f5 = r7;
                                        f5 = f5 * f4;
                                        f5 = f5 + f2;
                                        r8 = r5;
                                        repeat185:
                                        while (true) {
                                            f6 = r8;
                                            f6 = f6 * f4;
                                            f6 = f6 + f2;
                                            heapClassInst.heapFloat[r0 + numDefine12] = (float) f6;
                                            heapClassInst.heapFloat[r0 + numDefine13] = (float) f1;
                                            heapClassInst.heapFloat[r0 + numDefine14] = (float) f5;
                                            heapClassInst.heap32[r0 + numDefine15] = 0;
                                            r9 = heapClassInst.heap32[r1];
                                            r9 = r9 >> numDefine2;
                                            r9 = heapClassInst.heap32[r9 + numDefine2];
                                            heapClassInst.heap32[g0] = r6;
                                            heapClassInst.heap32[g0 + 1] = numDefine53216;
                                            heapClassInst.heap32[g0 + numDefine2] = r4;
                                            heapClassInst.heap32[g0 + numDefine3] = r2;
                                            r8 = (r8 + 1) | 0;
                                            functionTable.get(r9 >> numDefine2).accept(i7);
                                            if (!(r8 != numDefine8)) {
                                                break repeat185;
                                            }
                                        }
                                        r7 = (r7 + 1) | 0;
                                        if (!(r7 != numDefine8)) {
                                            break repeat183;
                                        }
                                    }
                                    f4 = numDefineFloat068;
                                    f5 = numDefineNegFloat006;
                                    f4 = f3 * f4;
                                    f6 = numDefine3;
                                    f3 = f3 * f5;
                                    f5 = numDefine7;
                                    f6 = f4 + f6;
                                    f3 = f3 * f5;
                                    r3 = (r3 + -1) | 0;
                                    f1 = f1 + f6;
                                    f2 = f3 + f2;
                                    f3 = f4;
                                    if (r3 == 0) {
                                        break repeat161;
                                    } else {
                                        continue repeat181;
                                    }
                                }
                            } else {
                                if (r0 == numDefine5) {
                                    r3 = numDefine10;
                                    f0 = numDefine20;
                                    f1 = numDefine2;
                                    f2 = numDefineNeg25;
                                    repeat191:
                                    while (true) {
                                        f3 = numDefine3;
                                        f4 = numDefine25;
                                        f5 = f1 + f3;
                                        f4 = f0 + f4;
                                        r0 = 0;
                                        r5 = r0;
                                        repeat193:
                                        while (true) {
                                            f6 = r5;
                                            f6 = f6 * f5;
                                            f6 = f6 + f2;
                                            f7 = numDefine5;
                                            f6 = f6 * f7;
                                            f8 = 0;
                                            f6 = f6 + f8;
                                            r7 = r0;
                                            repeat195:
                                            while (true) {
                                                r8 = zl8nextRand;
                                                r8 = r8 >> numDefine2;
                                                r9 = heapClassInst.heap32[r8];
                                                r9 = (r9 * numDefine14013) | 0;
                                                r9 = (int) ((r9 + numDefine31011) | 0);
                                                r10 = sp + numDefineNeg64;
                                                heapClassInst.heap32[r8] = r9;
                                                r8 = r10 >> numDefine2;
                                                heapClassInst.heap32[fp + numDefineNeg16] = numDefine53216;
                                                heapClassInst.heap32[r8 + 1] = 0;
                                                heapClassInst.heap32[r8 + numDefine2] = 0;
                                                heapClassInst.heap32[r8 + numDefine3] = 0;
                                                heapClassInst.heap32[r8 + numDefine4] = 0;
                                                heapClassInst.heap32[r8 + numDefine5] = numDefine53216;
                                                heapClassInst.heap32[r8 + numDefine6] = 0;
                                                heapClassInst.heap32[r8 + numDefine7] = 0;
                                                f9 = r7;
                                                heapClassInst.heap32[r8 + numDefine8] = 0;
                                                f9 = f9 * f5;
                                                heapClassInst.heap32[r8 + numDefine9] = 0;
                                                f9 = f9 + f2;
                                                heapClassInst.heap32[r8 + numDefine10] = numDefine53216;
                                                f9 = f9 * f7;
                                                f9 = f9 + f8;
                                                heapClassInst.heap32[r8 + numDefine11] = 0;
                                                r9 = r9 >>> numDefine16;
                                                heapClassInst.heapFloat[r8 + numDefine12] = (float) f9;
                                                r9 = r9 & numDefine32767;
                                                heapClassInst.heapFloat[r8 + numDefine13] = (float) f4;
                                                r9 = (int) Math.floor(uint(r9) % uint(numDefine9));
                                                heapClassInst.heapFloat[r8 + numDefine14] = (float) f6;
                                                heapClassInst.heap32[r8 + numDefine15] = 0;
                                                if (!(uint(r9) > uint(numDefine8))) {
                                                    r8 = r4 << r9;
                                                    r11 = r8 & numDefine7;
                                                    if (r11 != 0) {
                                                        r8 = heapClassInst.heap32[r2];
                                                        r8 = (r8 + 1) | 0;
                                                        heapClassInst.heap32[r2] = r8;
                                                        r9 = (r9 + 1) | 0;
                                                        f9 = r9;
                                                        f10 = numDefineFloat05;
                                                        heapClassInst.heap32[g0] = numDefine71;
                                                        f9 = f9 * f10;
                                                        f10 = numDefineFloat15;
                                                        mallocNew(i7);
                                                        r9 = commonVariable.rg0;
                                                        f10 = f9 * f10;
                                                        if (r9 != 0) {
                                                            r8 = 0;
                                                            r11 = (r9 + numDefine4) | 0;
                                                            r8 = (r8 - r11) | 0;
                                                            r8 = r8 & numDefine15;
                                                            r8 = (r9 + r8) | 0;
                                                            r11 = (r8 + numDefine4) | 0;
                                                            r8 = r8 >> numDefine2;
                                                            heapClassInst.heap32[r8] = r9;
                                                            r9 = r11;
                                                        }
                                                        r8 = r9 >> numDefine2;
                                                        heapClassInst.heap32[r8 + numDefine2] = 0;
                                                        heapClassInst.heap32[r8 + numDefine3] = numDefine53216;
                                                        heapClassInst.heap32[r8 + numDefine4] = numDefine53216;
                                                        heapClassInst.heap32[r8 + numDefine5] = numDefine53216;
                                                        r11 = ztv10btBoxShape;
                                                        heapClassInst.heap32[r8 + numDefine6] = 0;
                                                        r11 = (r11 + numDefine8) | 0;
                                                        heapClassInst.heap32[r8 + numDefine11] = numDefine58986;
                                                        heapClassInst.heap32[r8] = r11;
                                                        f11 = numDefineNegFloat028;
                                                        f10 = f10 + f11;
                                                        heapClassInst.heap32[r8 + 1] = 0;
                                                        heapClassInst.heapFloat[r8 + numDefine7] = (float) f10;
                                                        heapClassInst.heapFloat[r8 + numDefine8] = (float) f10;
                                                        heapClassInst.heapFloat[r8 + numDefine9] = (float) f10;
                                                        heapClassInst.heap32[r8 + numDefine10] = 0;
                                                        r8 = heapClassInst.heap32[r1];
                                                        r8 = r8 >> numDefine2;
                                                        r8 = heapClassInst.heap32[r8 + numDefine2];
                                                        heapClassInst.heap32[g0] = r6;
                                                        heapClassInst.heapFloat[g0 + 1] = (float) f9;
                                                        heapClassInst.heap32[g0 + numDefine2] = r10;
                                                        heapClassInst.heap32[g0 + numDefine3] = r9;
                                                        functionTable.get(r8 >> numDefine2).accept(i7);
                                                    } else {
                                                        r11 = r8 & numDefine56;
                                                        if (r11 != 0) {
                                                            r8 = heapClassInst.heap32[r2];
                                                            r8 = (r8 + 1) | 0;
                                                            heapClassInst.heap32[r2] = r8;
                                                            r9 = (r9 + numDefineNeg2) | 0;
                                                            heapClassInst.heap32[g0] = numDefine71;
                                                            f9 = r9;
                                                            f10 = numDefineFloat05;
                                                            mallocNew(i7);
                                                            r9 = commonVariable.rg0;
                                                            f9 = f9 * f10;
                                                            if (r9 != 0) {
                                                                r8 = 0;
                                                                r11 = (r9 + numDefine4) | 0;
                                                                r8 = (r8 - r11) | 0;
                                                                r8 = r8 & numDefine15;
                                                                r8 = (r9 + r8) | 0;
                                                                r11 = (r8 + numDefine4) | 0;
                                                                r8 = r8 >> numDefine2;
                                                                heapClassInst.heap32[r8] = r9;
                                                                r9 = r11;
                                                            }
                                                            r8 = r9 >> numDefine2;
                                                            heapClassInst.heap32[r8 + numDefine2] = 0;
                                                            heapClassInst.heap32[r8 + numDefine3] = numDefine53216;
                                                            heapClassInst.heap32[r8 + numDefine4] = numDefine53216;
                                                            r11 = ztv13btSphereShape;
                                                            heapClassInst.heap32[r8 + numDefine5] = numDefine53216;
                                                            r11 = (r11 + numDefine8) | 0;
                                                            heapClassInst.heap32[r8 + numDefine6] = 0;
                                                            heapClassInst.heap32[r8] = r11;
                                                            f10 = numDefineFloat15;
                                                            f10 = f9 * f10;
                                                            heapClassInst.heap32[r8 + 1] = numDefine8;
                                                            heapClassInst.heapFloat[r8 + numDefine7] = (float) f10;
                                                            heapClassInst.heapFloat[r8 + numDefine11] = (float) f10;
                                                            r8 = heapClassInst.heap32[r1];
                                                            r8 = r8 >> numDefine2;
                                                            r8 = heapClassInst.heap32[r8 + numDefine2];
                                                            heapClassInst.heap32[g0] = r6;
                                                            heapClassInst.heapFloat[g0 + 1] = (float) f9;
                                                            heapClassInst.heap32[g0 + numDefine2] = r10;
                                                            heapClassInst.heap32[g0 + numDefine3] = r9;
                                                            functionTable.get(r8 >> numDefine2).accept(i7);
                                                        } else {
                                                            r8 = r8 & numDefine448;
                                                            if (r8 != 0) {
                                                                r8 = heapClassInst.heap32[r2];
                                                                r8 = (r8 + 1) | 0;
                                                                heapClassInst.heap32[r2] = r8;
                                                                r8 = (r9 + numDefineNeg5) | 0;
                                                                heapClassInst.heap32[g0] = numDefine75;
                                                                f9 = r8;
                                                                f10 = numDefineFloat05;
                                                                mallocNew(i7);
                                                                r8 = commonVariable.rg0;
                                                                f9 = f9 * f10;
                                                                if (r8 != 0) {
                                                                    r9 = 0;
                                                                    r11 = (r8 + numDefine4) | 0;
                                                                    r9 = (r9 - r11) | 0;
                                                                    r9 = r9 & numDefine15;
                                                                    r9 = (r8 + r9) | 0;
                                                                    r11 = (r9 + numDefine4) | 0;
                                                                    r9 = r9 >> numDefine2;
                                                                    heapClassInst.heap32[r9] = r8;
                                                                    r8 = r11;
                                                                }
                                                                r9 = r8 >> numDefine2;
                                                                heapClassInst.heap32[r9 + numDefine2] = 0;
                                                                heapClassInst.heap32[r9 + numDefine3] = numDefine53216;
                                                                heapClassInst.heap32[r9 + numDefine4] = numDefine53216;
                                                                heapClassInst.heap32[r9 + numDefine5] = numDefine53216;
                                                                r11 = ztv14btCapsuleShape;
                                                                heapClassInst.heap32[r9 + numDefine6] = 0;
                                                                r11 = (r11 + numDefine8) | 0;
                                                                heapClassInst.heap32[r9 + numDefine11] = numDefine58986;
                                                                heapClassInst.heap32[r9] = r11;
                                                                heapClassInst.heap32[r9 + 1] = numDefine10;
                                                                heapClassInst.heap32[r9 + numDefine13] = 1;
                                                                f11 = f9 + f9;
                                                                f10 = f11 * f10;
                                                                heapClassInst.heapFloat[r9 + numDefine7] = (float) f9;
                                                                heapClassInst.heapFloat[r9 + numDefine8] = (float) f10;
                                                                heapClassInst.heapFloat[r9 + numDefine9] = (float) f9;
                                                                heapClassInst.heap32[r9 + numDefine10] = 0;
                                                                r9 = heapClassInst.heap32[r1];
                                                                r9 = r9 >> numDefine2;
                                                                r9 = heapClassInst.heap32[r9 + numDefine2];
                                                                heapClassInst.heap32[g0] = r6;
                                                                heapClassInst.heapFloat[g0 + 1] = (float) f9;
                                                                heapClassInst.heap32[g0 + numDefine2] = r10;
                                                                heapClassInst.heap32[g0 + numDefine3] = r8;
                                                                functionTable.get(r9 >> numDefine2).accept(i7);
                                                            }
                                                        }
                                                    }
                                                }
                                                r7 = (r7 + 1) | 0;
                                                if (!(r7 != numDefine10)) {
                                                    break repeat195;
                                                }
                                            }
                                            r5 = (r5 + 1) | 0;
                                            if (!(r5 != numDefine10)) {
                                                break repeat193;
                                            }
                                        }
                                        f4 = numDefineFloat179;
                                        f5 = numDefineNegFloat006;
                                        f4 = f1 * f4;
                                        f1 = f1 * f5;
                                        f5 = numDefine9;
                                        f3 = f4 + f3;
                                        f1 = f1 * f5;
                                        r3 = (r3 + -1) | 0;
                                        f0 = f0 + f3;
                                        f2 = f1 + f2;
                                        f1 = f4;
                                        if (!(r3 != 0)) {
                                            break repeat191;
                                        }
                                    }
                                    zn13BenchmarkDemo19createLargeMeshBodyEv(i7);
                                    return;
                                } else {
                                    break repeat161;
                                }
                            }
                        }
                    } else {
                        if (r0 == 1) {
                            r3 = heapClassInst.heap32[r2];
                            r3 = (r3 + 1) | 0;
                            heapClassInst.heap32[r2] = r3;
                            heapClassInst.heap32[g0] = numDefine71;
                            mallocNew(i7);
                            r2 = commonVariable.rg0;
                            if (r2 != 0) {
                                r3 = 0;
                                r4 = (r2 + numDefine4) | 0;
                                r3 = (r3 - r4) | 0;
                                r3 = r3 & numDefine15;
                                r3 = (r2 + r3) | 0;
                                r4 = (r3 + numDefine4) | 0;
                                r3 = r3 >> numDefine2;
                                heapClassInst.heap32[r3] = r2;
                                r2 = r4;
                            }
                            r3 = r2 >> numDefine2;
                            heapClassInst.heap32[r3 + numDefine2] = 0;
                            heapClassInst.heap32[r3 + numDefine3] = numDefine53216;
                            heapClassInst.heap32[r3 + numDefine4] = numDefine53216;
                            heapClassInst.heap32[r3 + numDefine5] = numDefine53216;
                            r4 = ztv10btBoxShape;
                            heapClassInst.heap32[r3 + numDefine6] = 0;
                            r4 = (r4 + numDefine8) | 0;
                            heapClassInst.heap32[r3 + numDefine11] = numDefine58986;
                            heapClassInst.heap32[r3] = r4;
                            heapClassInst.heap32[r3 + 1] = 0;
                            heapClassInst.heap32[r3 + numDefine7] = numDefine82127;
                            heapClassInst.heap32[r3 + numDefine8] = numDefine82127;
                            heapClassInst.heap32[r3 + numDefine9] = numDefine82127;
                            r4 = sp + numDefineNeg1152;
                            heapClassInst.heap32[r3 + numDefine10] = 0;
                            r3 = r4 >> numDefine2;
                            heapClassInst.heap32[fp + numDefineNeg288] = 0;
                            heapClassInst.heap32[r3 + 1] = 0;
                            heapClassInst.heap32[r3 + numDefine2] = 0;
                            heapClassInst.heap32[r3 + numDefine3] = 0;
                            heapClassInst.heap32[g0] = r2;
                            heapClassInst.heap32[g0 + 1] = numDefine41824;
                            heapClassInst.heap32[g0 + numDefine2] = r4;
                            znk10btBoxShape21calculateLocalInertiaEfR9btVector3(i7);
                            r3 = sp + numDefineNeg1216;
                            r4 = r3 >> numDefine2;
                            heapClassInst.heap32[fp + numDefineNeg304] = numDefine53216;
                            heapClassInst.heap32[r4 + 1] = 0;
                            heapClassInst.heap32[r4 + numDefine2] = 0;
                            heapClassInst.heap32[r4 + numDefine3] = 0;
                            heapClassInst.heap32[r4 + numDefine4] = 0;
                            heapClassInst.heap32[r4 + numDefine5] = numDefine53216;
                            heapClassInst.heap32[r4 + numDefine6] = 0;
                            heapClassInst.heap32[r4 + numDefine7] = 0;
                            heapClassInst.heap32[r4 + numDefine8] = 0;
                            heapClassInst.heap32[r4 + numDefine9] = 0;
                            heapClassInst.heap32[r4 + numDefine10] = numDefine53216;
                            heapClassInst.heap32[r4 + numDefine11] = 0;
                            heapClassInst.heap32[r4 + numDefine12] = 0;
                            heapClassInst.heap32[r4 + numDefine13] = 0;
                            r0 = numDefine47;
                            f0 = numDefineNeg12;
                            f1 = numDefine2;
                            heapClassInst.heap32[r4 + numDefine14] = 0;
                            heapClassInst.heap32[r4 + numDefine15] = 0;
                            repeat225:
                            while (true) {
                                r5 = 0;
                                r7 = r5;
                                repeat227:
                                while (true) {
                                    f2 = r7;
                                    f3 = numDefine3;
                                    f2 = f2 * f3;
                                    f2 = f2 + f0;
                                    r8 = r5;
                                    repeat229:
                                    while (true) {
                                        f4 = r8;
                                        f4 = f4 * f3;
                                        f4 = f4 + f0;
                                        heapClassInst.heapFloat[r4 + numDefine12] = (float) f4;
                                        heapClassInst.heapFloat[r4 + numDefine13] = (float) f1;
                                        heapClassInst.heapFloat[r4 + numDefine14] = (float) f2;
                                        heapClassInst.heap32[r4 + numDefine15] = 0;
                                        r9 = heapClassInst.heap32[r1];
                                        r9 = r9 >> numDefine2;
                                        r9 = heapClassInst.heap32[r9 + numDefine2];
                                        heapClassInst.heap32[g0] = r6;
                                        heapClassInst.heap32[g0 + 1] = numDefine41824;
                                        heapClassInst.heap32[g0 + numDefine2] = r3;
                                        heapClassInst.heap32[g0 + numDefine3] = r2;
                                        r8 = (r8 + 1) | 0;
                                        functionTable.get(r9 >> numDefine2).accept(i7);
                                        if (!(r8 != numDefine8)) {
                                            break repeat229;
                                        }
                                    }
                                    r7 = (r7 + 1) | 0;
                                    if (!(r7 != numDefine8)) {
                                        break repeat227;
                                    }
                                }
                                f2 = numDefineNegFloat352;
                                r0 = (r0 + -1) | 0;
                                f1 = f1 + f3;
                                f0 = f0 + f2;
                                if (r0 == 0) {
                                    break repeat161;
                                } else {
                                    continue repeat225;
                                }
                            }
                        } else {
                            if (r0 == numDefine2) {
                                r3 = heapClassInst.heap32[r2];
                                r3 = (r3 + 1) | 0;
                                heapClassInst.heap32[r2] = r3;
                                heapClassInst.heap32[g0] = numDefine71;
                                mallocNew(i7);
                                r3 = commonVariable.rg0;
                                if (r3 != 0) {
                                    r4 = 0;
                                    r0 = (r3 + numDefine4) | 0;
                                    r4 = (r4 - r0) | 0;
                                    r4 = r4 & numDefine15;
                                    r4 = (r3 + r4) | 0;
                                    r0 = (r4 + numDefine4) | 0;
                                    r4 = r4 >> numDefine2;
                                    heapClassInst.heap32[r4] = r3;
                                    r3 = r0;
                                }
                                r4 = r3 >> numDefine2;
                                heapClassInst.heap32[r4 + numDefine2] = 0;
                                heapClassInst.heap32[r4 + numDefine3] = numDefine53216;
                                heapClassInst.heap32[r4 + numDefine4] = numDefine53216;
                                heapClassInst.heap32[r4 + numDefine5] = numDefine53216;
                                r0 = ztv10btBoxShape;
                                heapClassInst.heap32[r4 + numDefine6] = 0;
                                r0 = (r0 + numDefine8) | 0;
                                heapClassInst.heap32[r4 + numDefine11] = numDefine58986;
                                heapClassInst.heap32[r4] = r0;
                                heapClassInst.heap32[r4 + 1] = 0;
                                heapClassInst.heap32[r4 + numDefine7] = numDefine82127;
                                heapClassInst.heap32[r4 + numDefine8] = numDefine82127;
                                heapClassInst.heap32[r4 + numDefine9] = numDefine82127;
                                r5 = sp + numDefineNeg1024;
                                heapClassInst.heap32[r4 + numDefine10] = 0;
                                r4 = r5 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg256] = numDefine53216;
                                heapClassInst.heap32[r4 + 1] = 0;
                                heapClassInst.heap32[r4 + numDefine2] = 0;
                                heapClassInst.heap32[r4 + numDefine3] = 0;
                                heapClassInst.heap32[r4 + numDefine4] = 0;
                                heapClassInst.heap32[r4 + numDefine5] = numDefine53216;
                                heapClassInst.heap32[r4 + numDefine6] = 0;
                                heapClassInst.heap32[r4 + numDefine7] = 0;
                                heapClassInst.heap32[r4 + numDefine8] = 0;
                                heapClassInst.heap32[r4 + numDefine9] = 0;
                                heapClassInst.heap32[r4 + numDefine10] = numDefine53216;
                                heapClassInst.heap32[r4 + numDefine11] = 0;
                                heapClassInst.heap32[r4 + numDefine12] = 0;
                                heapClassInst.heap32[r4 + numDefine13] = 0;
                                heapClassInst.heap32[r4 + numDefine14] = 0;
                                r7 = sp + numDefineNeg1040;
                                heapClassInst.heap32[r4 + numDefine15] = 0;
                                r8 = r7 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg260] = 0;
                                heapClassInst.heap32[r8 + 1] = 0;
                                heapClassInst.heap32[r8 + numDefine2] = 0;
                                heapClassInst.heap32[r8 + numDefine3] = 0;
                                heapClassInst.heap32[g0] = r3;
                                heapClassInst.heap32[g0 + 1] = numDefine53216;
                                heapClassInst.heap32[g0 + numDefine2] = r7;
                                r7 = numDefine12;
                                f0 = numDefineNegFloat267;
                                f1 = 1;
                                znk10btBoxShape21calculateLocalInertiaEfR9btVector3(i7);
                                f2 = f0;
                                f8 = numDefineNeg20;
                                repeat239:
                                while (true) {
                                    if (!(r7 < 1)) {
                                        f4 = 0;
                                        f3 = f1 + f4;
                                        r8 = 0;
                                        r9 = r8;
                                        repeat243:
                                        while (true) {
                                            f5 = r9;
                                            f6 = numDefineFloat009;
                                            f5 = f5 * f6;
                                            f5 = f5 + f0;
                                            f5 = f5 + f4;
                                            r10 = r8;
                                            repeat245:
                                            while (true) {
                                                f7 = r10;
                                                f7 = f7 * f6;
                                                f7 = f7 + f2;
                                                f7 = f7 + f8;
                                                heapClassInst.heapFloat[r4 + numDefine12] = (float) f7;
                                                heapClassInst.heapFloat[r4 + numDefine13] = (float) f3;
                                                heapClassInst.heapFloat[r4 + numDefine14] = (float) f5;
                                                heapClassInst.heap32[r4 + numDefine15] = 0;
                                                r11 = heapClassInst.heap32[r1];
                                                r11 = r11 >> numDefine2;
                                                r11 = heapClassInst.heap32[r11 + numDefine2];
                                                heapClassInst.heap32[g0] = r6;
                                                heapClassInst.heap32[g0 + 1] = numDefine53216;
                                                heapClassInst.heap32[g0 + numDefine2] = r5;
                                                heapClassInst.heap32[g0 + numDefine3] = r3;
                                                r10 = (r10 + 1) | 0;
                                                functionTable.get(r11 >> numDefine2).accept(i7);
                                                if (!(r7 != r10)) {
                                                    break repeat245;
                                                }
                                            }
                                            r9 = (r9 + 1) | 0;
                                            if (!(r7 != r9)) {
                                                break repeat243;
                                            }
                                        }
                                    }
                                    f3 = numDefineFloat009;
                                    f4 = numDefineFloat037;
                                    r7 = (r7 + -1) | 0;
                                    f1 = f1 + f3;
                                    f0 = f0 + f4;
                                    f2 = f2 + f4;
                                    if (r7 == 0) {
                                        break repeat239;
                                    }
                                }
                                r3 = sp + numDefineNeg1136;
                                r4 = r3 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg284] = numDefine53216;
                                heapClassInst.heap32[r4 + 1] = numDefine53216;
                                heapClassInst.heap32[r4 + numDefine2] = numDefine53216;
                                r5 = sp + numDefineNeg1120;
                                heapClassInst.heap32[r4 + numDefine3] = 0;
                                r4 = r5 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg280] = numDefineNeg41824;
                                heapClassInst.heap32[r4 + 1] = 0;
                                heapClassInst.heap32[r4 + numDefine2] = 0;
                                heapClassInst.heap32[r4 + numDefine3] = 0;
                                heapClassInst.heap32[g0] = r5;
                                heapClassInst.heap32[g0 + 1] = r3;
                                r3 = sp + numDefineNeg1104;
                                zn13BenchmarkDemo10createWallERK9btVector3iS2(i7);
                                r4 = r3 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg276] = numDefine53216;
                                heapClassInst.heap32[r4 + 1] = numDefine53216;
                                heapClassInst.heap32[r4 + numDefine2] = numDefine53216;
                                r5 = sp + numDefineNeg1088;
                                heapClassInst.heap32[r4 + numDefine3] = 0;
                                r4 = r5 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg272] = numDefine30432;
                                heapClassInst.heap32[r4 + 1] = 0;
                                heapClassInst.heap32[r4 + numDefine2] = 0;
                                heapClassInst.heap32[r4 + numDefine3] = 0;
                                heapClassInst.heap32[g0] = r5;
                                heapClassInst.heap32[g0 + 1] = r3;
                                r3 = sp + numDefineNeg1072;
                                zn13BenchmarkDemo10createWallERK9btVector3iS2(i7);
                                r4 = r3 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg268] = numDefine53216;
                                heapClassInst.heap32[r4 + 1] = numDefine53216;
                                heapClassInst.heap32[r4 + numDefine2] = numDefine53216;
                                r5 = sp + numDefineNeg1056;
                                heapClassInst.heap32[r4 + numDefine3] = 0;
                                r4 = r5 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg264] = numDefine16192;
                                heapClassInst.heap32[r4 + 1] = 0;
                                heapClassInst.heap32[r4 + numDefine2] = 0;
                                heapClassInst.heap32[r4 + numDefine3] = 0;
                                heapClassInst.heap32[g0] = r5;
                                heapClassInst.heap32[g0 + 1] = r3;
                                zn13BenchmarkDemo10createWallERK9btVector3iS2(i7);
                                r3 = heapClassInst.heap32[r2];
                                r3 = (r3 + 1) | 0;
                                heapClassInst.heap32[r2] = r3;
                                heapClassInst.heap32[g0] = numDefine71;
                                mallocNew(i7);
                                r2 = commonVariable.rg0;
                                if (r2 != 0) {
                                    r3 = 0;
                                    r4 = (r2 + numDefine4) | 0;
                                    r3 = (r3 - r4) | 0;
                                    r3 = r3 & numDefine15;
                                    r3 = (r2 + r3) | 0;
                                    r4 = (r3 + numDefine4) | 0;
                                    r3 = r3 >> numDefine2;
                                    heapClassInst.heap32[r3] = r2;
                                    r2 = r4;
                                }
                                r3 = r2 >> numDefine2;
                                heapClassInst.heap32[r3 + numDefine2] = 0;
                                heapClassInst.heap32[r3 + numDefine3] = numDefine53216;
                                heapClassInst.heap32[r3 + numDefine4] = numDefine53216;
                                heapClassInst.heap32[r3 + numDefine5] = numDefine53216;
                                heapClassInst.heap32[r3 + numDefine6] = 0;
                                heapClassInst.heap32[r3 + numDefine11] = numDefine58986;
                                heapClassInst.heap32[r3] = r0;
                                heapClassInst.heap32[r3 + 1] = 0;
                                heapClassInst.heap32[r3 + numDefine7] = numDefine82127;
                                heapClassInst.heap32[r3 + numDefine8] = numDefine82127;
                                heapClassInst.heap32[r3 + numDefine9] = numDefine82127;
                                r4 = sp + numDefineNeg944;
                                heapClassInst.heap32[r3 + numDefine10] = 0;
                                r3 = r4 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg236] = numDefine53216;
                                heapClassInst.heap32[r3 + 1] = 0;
                                heapClassInst.heap32[r3 + numDefine2] = 0;
                                heapClassInst.heap32[r3 + numDefine3] = 0;
                                heapClassInst.heap32[r3 + numDefine4] = 0;
                                heapClassInst.heap32[r3 + numDefine5] = numDefine53216;
                                heapClassInst.heap32[r3 + numDefine6] = 0;
                                heapClassInst.heap32[r3 + numDefine7] = 0;
                                heapClassInst.heap32[r3 + numDefine8] = 0;
                                heapClassInst.heap32[r3 + numDefine9] = 0;
                                heapClassInst.heap32[r3 + numDefine10] = numDefine53216;
                                heapClassInst.heap32[r3 + numDefine11] = 0;
                                heapClassInst.heap32[r3 + numDefine12] = 0;
                                heapClassInst.heap32[r3 + numDefine13] = 0;
                                heapClassInst.heap32[r3 + numDefine14] = 0;
                                r0 = sp + numDefineNeg960;
                                heapClassInst.heap32[r3 + numDefine15] = 0;
                                r5 = r0 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg240] = 0;
                                heapClassInst.heap32[r5 + 1] = 0;
                                heapClassInst.heap32[r5 + numDefine2] = 0;
                                heapClassInst.heap32[r5 + numDefine3] = 0;
                                heapClassInst.heap32[g0] = r2;
                                heapClassInst.heap32[g0 + 1] = numDefine53216;
                                heapClassInst.heap32[g0 + numDefine2] = r0;
                                r0 = numDefine8;
                                f0 = 1;
                                f1 = 0;
                                znk10btBoxShape21calculateLocalInertiaEfR9btVector3(i7);
                                f2 = f1;
                                f3 = f0;
                                f4 = f1;
                                repeat253:
                                while (true) {
                                    r5 = numDefine24;
                                    repeat255:
                                    while (true) {
                                        f5 = numDefineFloat952;
                                        f6 = 0;
                                        f7 = f3 * f0;
                                        f8 = f4 * f6;
                                        f9 = f3 * f5;
                                        f10 = f1 * f6;
                                        f7 = f8 + f7;
                                        f11 = f2 * f5;
                                        f9 = f10 + f9;
                                        f12 = f2 * f0;
                                        f13 = f1 * f0;
                                        f14 = f2 * f6;
                                        f7 = f7 + f11;
                                        f9 = f9 - f12;
                                        f11 = f13 + f14;
                                        f12 = f4 * f5;
                                        f5 = f1 * f5;
                                        f13 = f4 * f0;
                                        f11 = f11 - f12;
                                        f12 = f4 * f4;
                                        f15 = f3 * f3;
                                        f16 = f4 * f7;
                                        f17 = f1 * f9;
                                        f5 = f5 + f13;
                                        f13 = f3 * f6;
                                        f5 = f5 - f13;
                                        f12 = f12 + f15;
                                        f15 = f2 * f2;
                                        f18 = f3 * f7;
                                        f19 = f1 * f11;
                                        f16 = f16 + f17;
                                        f17 = f2 * f11;
                                        f12 = f12 + f15;
                                        f15 = f1 * f1;
                                        f7 = f2 * f7;
                                        f20 = f1 * f5;
                                        f18 = f18 + f19;
                                        f19 = f4 * f5;
                                        f16 = f16 - f17;
                                        f5 = f3 * f5;
                                        f17 = numDefine2;
                                        f12 = f12 + f15;
                                        f7 = f7 + f20;
                                        f15 = f3 * f9;
                                        f18 = f18 - f19;
                                        f9 = f2 * f9;
                                        f5 = f16 + f5;
                                        f16 = numDefine25;
                                        f12 = f17 / f12;
                                        f9 = f18 + f9;
                                        f5 = f5 + f16;
                                        f7 = f7 - f15;
                                        f11 = f4 * f11;
                                        f15 = f2 * f12;
                                        f16 = f3 * f12;
                                        f7 = f7 + f11;
                                        f9 = f9 + f6;
                                        heapClassInst.heapFloat[r3 + numDefine12] = (float) f5;
                                        f5 = f3 * f16;
                                        f11 = f2 * f15;
                                        f7 = f7 + f6;
                                        heapClassInst.heapFloat[r3 + numDefine13] = (float) f9;
                                        heapClassInst.heapFloat[r3 + numDefine14] = (float) f7;
                                        f7 = 1;
                                        f9 = f5 + f11;
                                        f18 = f4 * f16;
                                        f19 = f1 * f15;
                                        f9 = f7 - f9;
                                        heapClassInst.heap32[r3 + numDefine15] = 0;
                                        f20 = f4 * f15;
                                        f16 = f1 * f16;
                                        f21 = f18 - f19;
                                        heapClassInst.heapFloat[fp + numDefineNeg236] = (float) f9;
                                        f9 = f4 * f12;
                                        f12 = f20 + f16;
                                        heapClassInst.heapFloat[r3 + 1] = (float) f21;
                                        f21 = f4 * f9;
                                        heapClassInst.heapFloat[r3 + numDefine2] = (float) f12;
                                        f11 = f21 + f11;
                                        f12 = f18 + f19;
                                        heapClassInst.heap32[r3 + numDefine3] = 0;
                                        f15 = f3 * f15;
                                        f9 = f1 * f9;
                                        f11 = f7 - f11;
                                        heapClassInst.heapFloat[r3 + numDefine4] = (float) f12;
                                        f12 = f15 - f9;
                                        heapClassInst.heapFloat[r3 + numDefine5] = (float) f11;
                                        heapClassInst.heapFloat[r3 + numDefine6] = (float) f12;
                                        f11 = f20 - f16;
                                        heapClassInst.heap32[r3 + numDefine7] = 0;
                                        f5 = f21 + f5;
                                        f9 = f15 + f9;
                                        heapClassInst.heapFloat[r3 + numDefine8] = (float) f11;
                                        f5 = f7 - f5;
                                        heapClassInst.heapFloat[r3 + numDefine9] = (float) f9;
                                        heapClassInst.heapFloat[r3 + numDefine10] = (float) f5;
                                        heapClassInst.heap32[r3 + numDefine11] = 0;
                                        r7 = heapClassInst.heap32[r1];
                                        r7 = r7 >> numDefine2;
                                        f5 = numDefineFloat941;
                                        f7 = numDefineFloat176;
                                        r7 = heapClassInst.heap32[r7 + numDefine2];
                                        f9 = f1 * f5;
                                        f11 = f2 * f5;
                                        f12 = f4 * f5;
                                        f1 = f1 * f7;
                                        f5 = f3 * f5;
                                        f1 = f1 + f5;
                                        f5 = f10 + f12;
                                        f9 = f9 - f8;
                                        f3 = f3 * f7;
                                        f10 = f10 + f11;
                                        f4 = f4 * f7;
                                        f3 = f9 - f3;
                                        f4 = f10 + f4;
                                        f9 = f1 + f14;
                                        heapClassInst.heap32[g0] = r6;
                                        heapClassInst.heap32[g0 + 1] = numDefine53216;
                                        heapClassInst.heap32[g0 + numDefine2] = r4;
                                        heapClassInst.heap32[g0 + numDefine3] = r2;
                                        f5 = f5 + f13;
                                        f7 = f2 * f7;
                                        r5 = (r5 + -1) | 0;
                                        f1 = f3 - f14;
                                        f2 = f4 - f13;
                                        f3 = f9 - f8;
                                        f4 = f5 - f7;
                                        functionTable.get(r7 >> numDefine2).accept(i7);
                                        if (!(r5 != 0)) {
                                            break repeat255;
                                        }
                                    }
                                    f5 = numDefineFloat919;
                                    f7 = numDefineFloat063;
                                    f8 = f4 * f5;
                                    f9 = f1 * f6;
                                    f10 = f2 * f5;
                                    f11 = f1 * f7;
                                    f12 = f3 * f5;
                                    f1 = f1 * f5;
                                    f5 = f4 * f6;
                                    f8 = f9 + f8;
                                    f13 = f3 * f6;
                                    f11 = f11 + f12;
                                    f6 = f2 * f6;
                                    f9 = f9 + f10;
                                    f4 = f4 * f7;
                                    f1 = f1 - f5;
                                    f3 = f3 * f7;
                                    f10 = f11 + f6;
                                    f9 = f9 + f4;
                                    f1 = f1 - f3;
                                    f3 = f8 + f13;
                                    f2 = f2 * f7;
                                    r0 = (r0 + -1) | 0;
                                    f4 = f3 - f2;
                                    f3 = f10 - f5;
                                    f2 = f9 - f13;
                                    f1 = f1 - f6;
                                    f0 = f0 + f17;
                                    if (r0 == 0) {
                                        break repeat161;
                                    } else {
                                        continue repeat253;
                                    }
                                }
                            } else {
                                if (r0 == numDefine3) {
                                    r3 = numDefineNeg16;
                                    r0 = numDefine16;
                                    f0 = 0;
                                    f1 = 1;
                                    f2 = f0;
                                    repeat260:
                                    while (true) {
                                        f3 = r3;
                                        f4 = numDefine6;
                                        f3 = f3 * f4;
                                        f5 = numDefineFloat05;
                                        f6 = numDefineFloat35;
                                        f7 = numDefineFloat249;
                                        f8 = numDefineFloat584;
                                        f9 = numDefineFloat225;
                                        f10 = numDefineFloat604;
                                        f11 = numDefineFloat049;
                                        f3 = f3 * f5;
                                        f5 = f2 + f0;
                                        f6 = f1 + f6;
                                        f7 = f1 + f7;
                                        f8 = f1 + f8;
                                        f9 = f1 + f9;
                                        f10 = f1 + f10;
                                        f11 = f1 + f11;
                                        r5 = 0;
                                        repeat262:
                                        while (true) {
                                            heapClassInst.heap32[g0] = numDefine136;
                                            znwj(i7);
                                            r7 = commonVariable.rg0;
                                            r8 = ztv7RagDoll;
                                            r9 = r7 >> numDefine2;
                                            r10 = heapClassInst.heap32[r1 + 1];
                                            r8 = (r8 + numDefine8) | 0;
                                            heapClassInst.heap32[r9] = r8;
                                            heapClassInst.heap32[r9 + 1] = r10;
                                            r8 = heapClassInst.heap32[r2];
                                            r9 = (r8 + 1) | 0;
                                            heapClassInst.heap32[r2] = r9;
                                            f12 = r5;
                                            heapClassInst.heap32[g0] = numDefine75;
                                            f12 = f12 * f4;
                                            mallocNew(i7);
                                            r9 = commonVariable.rg0;
                                            f12 = f12 + f3;
                                            if (r9 != 0) {
                                                r10 = 0;
                                                r11 = (r9 + numDefine4) | 0;
                                                r10 = (r10 - r11) | 0;
                                                r10 = r10 & numDefine15;
                                                r10 = (r9 + r10) | 0;
                                                r11 = (r10 + numDefine4) | 0;
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10] = r9;
                                                r9 = r11;
                                            }
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            r11 = ztv14btCapsuleShape;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            r11 = (r11 + numDefine8) | 0;
                                            heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                                            heapClassInst.heap32[r10] = r11;
                                            heapClassInst.heap32[r10 + 1] = numDefine10;
                                            heapClassInst.heap32[r10 + numDefine13] = 1;
                                            heapClassInst.heap32[r10 + numDefine7] = numDefine84039;
                                            heapClassInst.heap32[r10 + numDefine8] = numDefine31443;
                                            heapClassInst.heap32[r10 + numDefine9] = numDefine84039;
                                            r12 = r7 >> numDefine2;
                                            heapClassInst.heap32[r10 + numDefine10] = 0;
                                            r10 = (r8 + numDefine2) | 0;
                                            heapClassInst.heap32[r12 + numDefine2] = r9;
                                            heapClassInst.heap32[r2] = r10;
                                            heapClassInst.heap32[g0] = numDefine75;
                                            mallocNew(i7);
                                            r9 = commonVariable.rg0;
                                            if (r9 != 0) {
                                                r10 = 0;
                                                r13 = (r9 + numDefine4) | 0;
                                                r10 = (r10 - r13) | 0;
                                                r10 = r10 & numDefine15;
                                                r10 = (r9 + r10) | 0;
                                                r13 = (r10 + numDefine4) | 0;
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10] = r9;
                                                r9 = r13;
                                            }
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                                            heapClassInst.heap32[r10] = r11;
                                            heapClassInst.heap32[r10 + 1] = numDefine10;
                                            heapClassInst.heap32[r10 + numDefine13] = 1;
                                            heapClassInst.heap32[r10 + numDefine7] = numDefine84039;
                                            heapClassInst.heap32[r10 + numDefine8] = numDefine29064;
                                            heapClassInst.heap32[r10 + numDefine9] = numDefine84039;
                                            heapClassInst.heap32[r10 + numDefine10] = 0;
                                            r10 = (r8 + numDefine3) | 0;
                                            heapClassInst.heap32[r12 + numDefine3] = r9;
                                            heapClassInst.heap32[r2] = r10;
                                            heapClassInst.heap32[g0] = numDefine75;
                                            mallocNew(i7);
                                            r9 = commonVariable.rg0;
                                            if (r9 != 0) {
                                                r10 = 0;
                                                r13 = (r9 + numDefine4) | 0;
                                                r10 = (r10 - r13) | 0;
                                                r10 = r10 & numDefine15;
                                                r10 = (r9 + r10) | 0;
                                                r13 = (r10 + numDefine4) | 0;
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10] = r9;
                                                r9 = r13;
                                            }
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                                            heapClassInst.heap32[r10] = r11;
                                            heapClassInst.heap32[r10 + 1] = numDefine10;
                                            heapClassInst.heap32[r10 + numDefine13] = 1;
                                            heapClassInst.heap32[r10 + numDefine7] = numDefine31443;
                                            heapClassInst.heap32[r10 + numDefine8] = numDefine54227;
                                            heapClassInst.heap32[r10 + numDefine9] = numDefine31443;
                                            heapClassInst.heap32[r10 + numDefine10] = 0;
                                            r10 = (r8 + numDefine4) | 0;
                                            heapClassInst.heap32[r12 + numDefine4] = r9;
                                            heapClassInst.heap32[r2] = r10;
                                            heapClassInst.heap32[g0] = numDefine75;
                                            mallocNew(i7);
                                            r9 = commonVariable.rg0;
                                            if (r9 != 0) {
                                                r10 = 0;
                                                r13 = (r9 + numDefine4) | 0;
                                                r10 = (r10 - r13) | 0;
                                                r10 = r10 & numDefine15;
                                                r10 = (r9 + r10) | 0;
                                                r13 = (r10 + numDefine4) | 0;
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10] = r9;
                                                r9 = r13;
                                            }
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                                            heapClassInst.heap32[r10] = r11;
                                            heapClassInst.heap32[r10 + 1] = numDefine10;
                                            heapClassInst.heap32[r10 + numDefine13] = 1;
                                            heapClassInst.heap32[r10 + numDefine7] = numDefine40456;
                                            heapClassInst.heap32[r10 + numDefine8] = numDefine88057;
                                            heapClassInst.heap32[r10 + numDefine9] = numDefine40456;
                                            heapClassInst.heap32[r10 + numDefine10] = 0;
                                            r10 = (r8 + numDefine5) | 0;
                                            heapClassInst.heap32[r12 + numDefine5] = r9;
                                            heapClassInst.heap32[r2] = r10;
                                            heapClassInst.heap32[g0] = numDefine75;
                                            mallocNew(i7);
                                            r9 = commonVariable.rg0;
                                            if (r9 != 0) {
                                                r10 = 0;
                                                r13 = (r9 + numDefine4) | 0;
                                                r10 = (r10 - r13) | 0;
                                                r10 = r10 & numDefine15;
                                                r10 = (r9 + r10) | 0;
                                                r13 = (r10 + numDefine4) | 0;
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10] = r9;
                                                r9 = r13;
                                            }
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                                            heapClassInst.heap32[r10] = r11;
                                            heapClassInst.heap32[r10 + 1] = numDefine10;
                                            heapClassInst.heap32[r10 + numDefine13] = 1;
                                            heapClassInst.heap32[r10 + numDefine7] = numDefine42835;
                                            heapClassInst.heap32[r10 + numDefine8] = numDefine39248;
                                            heapClassInst.heap32[r10 + numDefine9] = numDefine42835;
                                            heapClassInst.heap32[r10 + numDefine10] = 0;
                                            r10 = (r8 + numDefine6) | 0;
                                            heapClassInst.heap32[r12 + numDefine6] = r9;
                                            heapClassInst.heap32[r2] = r10;
                                            heapClassInst.heap32[g0] = numDefine75;
                                            mallocNew(i7);
                                            r9 = commonVariable.rg0;
                                            if (r9 != 0) {
                                                r10 = 0;
                                                r13 = (r9 + numDefine4) | 0;
                                                r10 = (r10 - r13) | 0;
                                                r10 = r10 & numDefine15;
                                                r10 = (r9 + r10) | 0;
                                                r13 = (r10 + numDefine4) | 0;
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10] = r9;
                                                r9 = r13;
                                            }
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                                            heapClassInst.heap32[r10] = r11;
                                            heapClassInst.heap32[r10 + 1] = numDefine10;
                                            heapClassInst.heap32[r10 + numDefine13] = 1;
                                            heapClassInst.heap32[r10 + numDefine7] = numDefine40456;
                                            heapClassInst.heap32[r10 + numDefine8] = numDefine88057;
                                            heapClassInst.heap32[r10 + numDefine9] = numDefine40456;
                                            heapClassInst.heap32[r10 + numDefine10] = 0;
                                            r10 = (r8 + numDefine7) | 0;
                                            heapClassInst.heap32[r12 + numDefine7] = r9;
                                            heapClassInst.heap32[r2] = r10;
                                            heapClassInst.heap32[g0] = numDefine75;
                                            mallocNew(i7);
                                            r9 = commonVariable.rg0;
                                            if (r9 != 0) {
                                                r10 = 0;
                                                r13 = (r9 + numDefine4) | 0;
                                                r10 = (r10 - r13) | 0;
                                                r10 = r10 & numDefine15;
                                                r10 = (r9 + r10) | 0;
                                                r13 = (r10 + numDefine4) | 0;
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10] = r9;
                                                r9 = r13;
                                            }
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                                            heapClassInst.heap32[r10] = r11;
                                            heapClassInst.heap32[r10 + 1] = numDefine10;
                                            heapClassInst.heap32[r10 + numDefine13] = 1;
                                            heapClassInst.heap32[r10 + numDefine7] = numDefine42835;
                                            heapClassInst.heap32[r10 + numDefine8] = numDefine39248;
                                            heapClassInst.heap32[r10 + numDefine9] = numDefine42835;
                                            heapClassInst.heap32[r10 + numDefine10] = 0;
                                            r10 = (r8 + numDefine8) | 0;
                                            heapClassInst.heap32[r12 + numDefine8] = r9;
                                            heapClassInst.heap32[r2] = r10;
                                            heapClassInst.heap32[g0] = numDefine75;
                                            mallocNew(i7);
                                            r9 = commonVariable.rg0;
                                            if (r9 != 0) {
                                                r10 = 0;
                                                r13 = (r9 + numDefine4) | 0;
                                                r10 = (r10 - r13) | 0;
                                                r10 = r10 & numDefine15;
                                                r10 = (r9 + r10) | 0;
                                                r13 = (r10 + numDefine4) | 0;
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10] = r9;
                                                r9 = r13;
                                            }
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                                            heapClassInst.heap32[r10] = r11;
                                            heapClassInst.heap32[r10 + 1] = numDefine10;
                                            heapClassInst.heap32[r10 + numDefine13] = 1;
                                            heapClassInst.heap32[r10 + numDefine7] = numDefine42835;
                                            heapClassInst.heap32[r10 + numDefine8] = numDefine64843;
                                            heapClassInst.heap32[r10 + numDefine9] = numDefine42835;
                                            heapClassInst.heap32[r10 + numDefine10] = 0;
                                            r10 = (r8 + numDefine9) | 0;
                                            heapClassInst.heap32[r12 + numDefine9] = r9;
                                            heapClassInst.heap32[r2] = r10;
                                            heapClassInst.heap32[g0] = numDefine75;
                                            mallocNew(i7);
                                            r9 = commonVariable.rg0;
                                            if (r9 != 0) {
                                                r10 = 0;
                                                r13 = (r9 + numDefine4) | 0;
                                                r10 = (r10 - r13) | 0;
                                                r10 = r10 & numDefine15;
                                                r10 = (r9 + r10) | 0;
                                                r13 = (r10 + numDefine4) | 0;
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10] = r9;
                                                r9 = r13;
                                            }
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                                            heapClassInst.heap32[r10] = r11;
                                            heapClassInst.heap32[r10 + 1] = numDefine10;
                                            heapClassInst.heap32[r10 + numDefine13] = 1;
                                            heapClassInst.heap32[r10 + numDefine7] = numDefine94025;
                                            heapClassInst.heap32[r10 + numDefine8] = numDefine67456;
                                            heapClassInst.heap32[r10 + numDefine9] = numDefine94025;
                                            heapClassInst.heap32[r10 + numDefine10] = 0;
                                            r10 = (r8 + numDefine10) | 0;
                                            heapClassInst.heap32[r12 + numDefine10] = r9;
                                            heapClassInst.heap32[r2] = r10;
                                            heapClassInst.heap32[g0] = numDefine75;
                                            mallocNew(i7);
                                            r9 = commonVariable.rg0;
                                            if (r9 != 0) {
                                                r10 = 0;
                                                r13 = (r9 + numDefine4) | 0;
                                                r10 = (r10 - r13) | 0;
                                                r10 = r10 & numDefine15;
                                                r10 = (r9 + r10) | 0;
                                                r13 = (r10 + numDefine4) | 0;
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10] = r9;
                                                r9 = r13;
                                            }
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine11] = numDefine58986;
                                            heapClassInst.heap32[r10] = r11;
                                            heapClassInst.heap32[r10 + 1] = numDefine10;
                                            heapClassInst.heap32[r10 + numDefine13] = 1;
                                            heapClassInst.heap32[r10 + numDefine7] = numDefine42835;
                                            heapClassInst.heap32[r10 + numDefine8] = numDefine64843;
                                            heapClassInst.heap32[r10 + numDefine9] = numDefine42835;
                                            heapClassInst.heap32[r10 + numDefine10] = 0;
                                            r8 = (r8 + numDefine11) | 0;
                                            heapClassInst.heap32[r12 + numDefine11] = r9;
                                            heapClassInst.heap32[r2] = r8;
                                            heapClassInst.heap32[g0] = numDefine75;
                                            mallocNew(i7);
                                            r8 = commonVariable.rg0;
                                            if (r8 != 0) {
                                                r9 = 0;
                                                r10 = (r8 + numDefine4) | 0;
                                                r9 = (r9 - r10) | 0;
                                                r9 = r9 & numDefine15;
                                                r9 = (r8 + r9) | 0;
                                                r10 = (r9 + numDefine4) | 0;
                                                r9 = r9 >> numDefine2;
                                                heapClassInst.heap32[r9] = r8;
                                                r8 = r10;
                                            }
                                            r9 = r8 >> numDefine2;
                                            heapClassInst.heap32[r9 + numDefine2] = 0;
                                            heapClassInst.heap32[r9 + numDefine3] = numDefine53216;
                                            heapClassInst.heap32[r9 + numDefine4] = numDefine53216;
                                            heapClassInst.heap32[r9 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r9 + numDefine6] = 0;
                                            heapClassInst.heap32[r9 + numDefine11] = numDefine58986;
                                            heapClassInst.heap32[r9] = r11;
                                            heapClassInst.heap32[r9 + 1] = numDefine10;
                                            heapClassInst.heap32[r9 + numDefine13] = 1;
                                            heapClassInst.heap32[r9 + numDefine7] = numDefine94025;
                                            heapClassInst.heap32[r9 + numDefine8] = numDefine67456;
                                            heapClassInst.heap32[r9 + numDefine9] = numDefine94025;
                                            heapClassInst.heap32[r9 + numDefine10] = 0;
                                            heapClassInst.heap32[r12 + numDefine12] = r8;
                                            r8 = heapClassInst.heap32[r12 + numDefine2];
                                            r9 = sp + numDefineNeg880;
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg220] = numDefine53216;
                                            heapClassInst.heap32[r10 + 1] = 0;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = 0;
                                            heapClassInst.heap32[r10 + numDefine4] = 0;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine7] = 0;
                                            heapClassInst.heap32[r10 + numDefine8] = 0;
                                            heapClassInst.heap32[r10 + numDefine9] = 0;
                                            heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                                            f13 = 0;
                                            f13 = f12 + f13;
                                            heapClassInst.heap32[r10 + numDefine11] = 0;
                                            heapClassInst.heapFloat[r10 + numDefine12] = (float) f13;
                                            heapClassInst.heapFloat[r10 + numDefine13] = (float) f6;
                                            heapClassInst.heapFloat[r10 + numDefine14] = (float) f5;
                                            heapClassInst.heap32[r10 + numDefine15] = 0;
                                            heapClassInst.heap32[g0] = r7;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r8;
                                            zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                                            heapClassInst.heap32[r12 + numDefine13] = commonVariable.rg0;
                                            r8 = heapClassInst.heap32[r12 + numDefine3];
                                            r9 = sp + numDefineNeg816;
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg204] = numDefine53216;
                                            heapClassInst.heap32[r10 + 1] = 0;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = 0;
                                            heapClassInst.heap32[r10 + numDefine4] = 0;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine7] = 0;
                                            heapClassInst.heap32[r10 + numDefine8] = 0;
                                            heapClassInst.heap32[r10 + numDefine9] = 0;
                                            heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine11] = 0;
                                            heapClassInst.heapFloat[r10 + numDefine12] = (float) f13;
                                            heapClassInst.heapFloat[r10 + numDefine13] = (float) f7;
                                            heapClassInst.heapFloat[r10 + numDefine14] = (float) f5;
                                            heapClassInst.heap32[r10 + numDefine15] = 0;
                                            heapClassInst.heap32[g0] = r7;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r8;
                                            zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                                            heapClassInst.heap32[r12 + numDefine14] = commonVariable.rg0;
                                            r8 = heapClassInst.heap32[r12 + numDefine4];
                                            r9 = sp + numDefineNeg752;
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg188] = numDefine53216;
                                            heapClassInst.heap32[r10 + 1] = 0;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = 0;
                                            heapClassInst.heap32[r10 + numDefine4] = 0;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine7] = 0;
                                            heapClassInst.heap32[r10 + numDefine8] = 0;
                                            heapClassInst.heap32[r10 + numDefine9] = 0;
                                            heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine11] = 0;
                                            heapClassInst.heapFloat[r10 + numDefine12] = (float) f13;
                                            heapClassInst.heapFloat[r10 + numDefine13] = (float) f8;
                                            heapClassInst.heapFloat[r10 + numDefine14] = (float) f5;
                                            heapClassInst.heap32[r10 + numDefine15] = 0;
                                            heapClassInst.heap32[g0] = r7;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r8;
                                            zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                                            heapClassInst.heap32[r12 + numDefine15] = commonVariable.rg0;
                                            r8 = heapClassInst.heap32[r12 + numDefine5];
                                            r9 = sp + numDefineNeg688;
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg172] = numDefine53216;
                                            heapClassInst.heap32[r10 + 1] = 0;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = 0;
                                            heapClassInst.heap32[r10 + numDefine4] = 0;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine7] = 0;
                                            heapClassInst.heap32[r10 + numDefine8] = 0;
                                            heapClassInst.heap32[r10 + numDefine9] = 0;
                                            f13 = numDefineNegFloat642;
                                            heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                                            f13 = f12 + f13;
                                            heapClassInst.heap32[r10 + numDefine11] = 0;
                                            heapClassInst.heapFloat[r10 + numDefine12] = (float) f13;
                                            heapClassInst.heapFloat[r10 + numDefine13] = (float) f9;
                                            heapClassInst.heapFloat[r10 + numDefine14] = (float) f5;
                                            heapClassInst.heap32[r10 + numDefine15] = 0;
                                            heapClassInst.heap32[g0] = r7;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r8;
                                            zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                                            heapClassInst.heap32[r12 + numDefine16] = commonVariable.rg0;
                                            r8 = heapClassInst.heap32[r12 + numDefine6];
                                            r9 = sp + numDefineNeg624;
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg156] = numDefine53216;
                                            heapClassInst.heap32[r10 + 1] = 0;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = 0;
                                            heapClassInst.heap32[r10 + numDefine4] = 0;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine7] = 0;
                                            heapClassInst.heap32[r10 + numDefine8] = 0;
                                            heapClassInst.heap32[r10 + numDefine9] = 0;
                                            heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine11] = 0;
                                            heapClassInst.heapFloat[r10 + numDefine12] = (float) f13;
                                            heapClassInst.heapFloat[r10 + numDefine13] = (float) f10;
                                            heapClassInst.heapFloat[r10 + numDefine14] = (float) f5;
                                            heapClassInst.heap32[r10 + numDefine15] = 0;
                                            heapClassInst.heap32[g0] = r7;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r8;
                                            zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                                            heapClassInst.heap32[r12 + numDefine17] = commonVariable.rg0;
                                            r8 = heapClassInst.heap32[r12 + numDefine7];
                                            r9 = sp + numDefineNeg560;
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg140] = numDefine53216;
                                            heapClassInst.heap32[r10 + 1] = 0;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = 0;
                                            heapClassInst.heap32[r10 + numDefine4] = 0;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine7] = 0;
                                            heapClassInst.heap32[r10 + numDefine8] = 0;
                                            heapClassInst.heap32[r10 + numDefine9] = 0;
                                            f13 = numDefineFloat642;
                                            heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                                            f13 = f12 + f13;
                                            heapClassInst.heap32[r10 + numDefine11] = 0;
                                            heapClassInst.heapFloat[r10 + numDefine12] = (float) f13;
                                            heapClassInst.heapFloat[r10 + numDefine13] = (float) f9;
                                            heapClassInst.heapFloat[r10 + numDefine14] = (float) f5;
                                            heapClassInst.heap32[r10 + numDefine15] = 0;
                                            heapClassInst.heap32[g0] = r7;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r8;
                                            zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                                            heapClassInst.heap32[r12 + numDefine18] = commonVariable.rg0;
                                            r8 = heapClassInst.heap32[r12 + numDefine8];
                                            r9 = sp + numDefineNeg496;
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg124] = numDefine53216;
                                            heapClassInst.heap32[r10 + 1] = 0;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = 0;
                                            heapClassInst.heap32[r10 + numDefine4] = 0;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine7] = 0;
                                            heapClassInst.heap32[r10 + numDefine8] = 0;
                                            heapClassInst.heap32[r10 + numDefine9] = 0;
                                            heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine11] = 0;
                                            heapClassInst.heapFloat[r10 + numDefine12] = (float) f13;
                                            heapClassInst.heapFloat[r10 + numDefine13] = (float) f10;
                                            heapClassInst.heapFloat[r10 + numDefine14] = (float) f5;
                                            heapClassInst.heap32[r10 + numDefine15] = 0;
                                            heapClassInst.heap32[g0] = r7;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r8;
                                            zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                                            heapClassInst.heap32[r12 + numDefine19] = commonVariable.rg0;
                                            r8 = heapClassInst.heap32[r12 + numDefine9];
                                            r9 = sp + numDefineNeg432;
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg108] = numDefineNeg30578;
                                            heapClassInst.heap32[r10 + 1] = numDefineNeg30432;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = 0;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefineNeg30578;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine7] = 0;
                                            heapClassInst.heap32[r10 + numDefine8] = 0;
                                            heapClassInst.heap32[r10 + numDefine9] = 0;
                                            f13 = numDefineNegFloat279;
                                            heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                                            f13 = f12 + f13;
                                            heapClassInst.heap32[r10 + numDefine11] = 0;
                                            heapClassInst.heapFloat[r10 + numDefine12] = (float) f13;
                                            heapClassInst.heapFloat[r10 + numDefine13] = (float) f11;
                                            heapClassInst.heapFloat[r10 + numDefine14] = (float) f5;
                                            heapClassInst.heap32[r10 + numDefine15] = 0;
                                            heapClassInst.heap32[g0] = r7;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r8;
                                            zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                                            heapClassInst.heap32[r12 + numDefine20] = commonVariable.rg0;
                                            r8 = heapClassInst.heap32[r12 + numDefine10];
                                            r9 = sp + numDefineNeg368;
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg92] = numDefineNeg30578;
                                            heapClassInst.heap32[r10 + 1] = numDefineNeg30432;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = 0;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefineNeg30578;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine7] = 0;
                                            heapClassInst.heap32[r10 + numDefine8] = 0;
                                            heapClassInst.heap32[r10 + numDefine9] = 0;
                                            f13 = numDefineNegFloat458;
                                            heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                                            f13 = f12 + f13;
                                            heapClassInst.heap32[r10 + numDefine11] = 0;
                                            heapClassInst.heapFloat[r10 + numDefine12] = (float) f13;
                                            heapClassInst.heapFloat[r10 + numDefine13] = (float) f11;
                                            heapClassInst.heapFloat[r10 + numDefine14] = (float) f5;
                                            heapClassInst.heap32[r10 + numDefine15] = 0;
                                            heapClassInst.heap32[g0] = r7;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r8;
                                            zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                                            heapClassInst.heap32[r12 + numDefine21] = commonVariable.rg0;
                                            r8 = heapClassInst.heap32[r12 + numDefine11];
                                            r9 = sp + numDefineNeg304;
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg76] = numDefineNeg30578;
                                            heapClassInst.heap32[r10 + 1] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = 0;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefineNeg30432;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefineNeg30578;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine7] = 0;
                                            heapClassInst.heap32[r10 + numDefine8] = numDefineNeg83648;
                                            heapClassInst.heap32[r10 + numDefine9] = 0;
                                            f13 = numDefineFloat279;
                                            heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                                            f13 = f12 + f13;
                                            heapClassInst.heap32[r10 + numDefine11] = 0;
                                            heapClassInst.heapFloat[r10 + numDefine12] = (float) f13;
                                            heapClassInst.heapFloat[r10 + numDefine13] = (float) f11;
                                            heapClassInst.heapFloat[r10 + numDefine14] = (float) f5;
                                            heapClassInst.heap32[r10 + numDefine15] = 0;
                                            heapClassInst.heap32[g0] = r7;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r8;
                                            zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                                            heapClassInst.heap32[r12 + numDefine22] = commonVariable.rg0;
                                            r8 = heapClassInst.heap32[r12 + numDefine12];
                                            r9 = sp + numDefineNeg240;
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg60] = numDefineNeg30578;
                                            heapClassInst.heap32[r10 + 1] = numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = 0;
                                            heapClassInst.heap32[r10 + numDefine4] = numDefineNeg30432;
                                            heapClassInst.heap32[r10 + numDefine5] = numDefineNeg30578;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[r10 + numDefine7] = 0;
                                            heapClassInst.heap32[r10 + numDefine8] = numDefineNeg83648;
                                            heapClassInst.heap32[r10 + numDefine9] = 0;
                                            f13 = numDefineFloat458;
                                            heapClassInst.heap32[r10 + numDefine10] = numDefine53216;
                                            f12 = f12 + f13;
                                            heapClassInst.heap32[r10 + numDefine11] = 0;
                                            heapClassInst.heapFloat[r10 + numDefine12] = (float) f12;
                                            heapClassInst.heapFloat[r10 + numDefine13] = (float) f11;
                                            heapClassInst.heapFloat[r10 + numDefine14] = (float) f5;
                                            heapClassInst.heap32[r10 + numDefine15] = 0;
                                            heapClassInst.heap32[g0] = r7;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r8;
                                            zn7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(i7);
                                            r9 = 0;
                                            heapClassInst.heap32[r12 + numDefine23] = commonVariable.rg0;
                                            repeat297:
                                            while (true) {
                                                r8 = r9 << numDefine2;
                                                r8 = (r7 - r8) | 0;
                                                r8 = r8 >> numDefine2;
                                                r10 = heapClassInst.heap32[r8 + numDefine13];
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10 + numDefine109] = numDefine43341;
                                                heapClassInst.heap32[r10 + numDefine110] = numDefine36634;
                                                r10 = heapClassInst.heap32[r8 + numDefine13];
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10 + numDefine55] = numDefine97773;
                                                r8 = heapClassInst.heap32[r8 + numDefine13];
                                                r8 = r8 >> numDefine2;
                                                r9 = (r9 + -1) | 0;
                                                heapClassInst.heap32[r8 + numDefine116] = numDefine86381;
                                                heapClassInst.heap32[r8 + numDefine117] = numDefine38976;
                                                if (!(r9 != numDefineNeg11)) {
                                                    break repeat297;
                                                }
                                            }
                                            heapClassInst.heap32[g0] = numDefine748;
                                            znwj(i7);
                                            r8 = commonVariable.rg0;
                                            r9 = heapClassInst.heap32[r12 + numDefine14];
                                            r10 = heapClassInst.heap32[r12 + numDefine13];
                                            r11 = r8 >> numDefine2;
                                            heapClassInst.heap32[r11 + 1] = numDefine4;
                                            heapClassInst.heap32[r11 + numDefine2] = -1;
                                            r13 = 0;
                                            heapClassInst.heap32[r11 + numDefine3] = -1;
                                            heapClassInst.heap8[r8 + numDefine16] = (byte) r13;
                                            heapClassInst.heap32[r11 + numDefine5] = r10;
                                            heapClassInst.heap32[r11 + numDefine6] = r9;
                                            r9 = ztv17btHingeConstraint;
                                            heapClassInst.heap32[r11 + numDefine7] = 0;
                                            r9 = (r9 + numDefine8) | 0;
                                            heapClassInst.heap32[r11 + numDefine8] = numDefine53722;
                                            heapClassInst.heap32[r11] = r9;
                                            heapClassInst.heap32[r11 + numDefine135] = numDefineNeg30578;
                                            heapClassInst.heap32[r11 + numDefine136] = 0;
                                            heapClassInst.heap32[r11 + numDefine137] = numDefine53216;
                                            heapClassInst.heap32[r11 + numDefine138] = 0;
                                            heapClassInst.heap32[r11 + numDefine139] = numDefineNeg83648;
                                            heapClassInst.heap32[r11 + numDefine140] = numDefine53216;
                                            heapClassInst.heap32[r11 + numDefine141] = 0;
                                            heapClassInst.heap32[r11 + numDefine142] = 0;
                                            heapClassInst.heap32[r11 + numDefine143] = numDefineNeg30432;
                                            heapClassInst.heap32[r11 + numDefine144] = numDefineNeg83648;
                                            heapClassInst.heap32[r11 + numDefine145] = numDefineNeg30578;
                                            heapClassInst.heap32[r11 + numDefine146] = 0;
                                            heapClassInst.heap32[r11 + numDefine147] = 0;
                                            heapClassInst.heap32[r11 + numDefine148] = numDefine84039;
                                            heapClassInst.heap32[r11 + numDefine149] = 0;
                                            heapClassInst.heap32[r11 + numDefine150] = 0;
                                            heapClassInst.heap32[r11 + numDefine151] = numDefineNeg30578;
                                            heapClassInst.heap32[r11 + numDefine152] = 0;
                                            heapClassInst.heap32[r11 + numDefine153] = numDefine53216;
                                            heapClassInst.heap32[r11 + numDefine154] = 0;
                                            heapClassInst.heap32[r11 + numDefine155] = numDefineNeg83648;
                                            heapClassInst.heap32[r11 + numDefine156] = numDefine53216;
                                            heapClassInst.heap32[r11 + numDefine157] = 0;
                                            heapClassInst.heap32[r11 + numDefine158] = 0;
                                            heapClassInst.heap32[r11 + numDefine159] = numDefineNeg30432;
                                            heapClassInst.heap32[r11 + numDefine160] = numDefineNeg83648;
                                            heapClassInst.heap32[r11 + numDefine161] = numDefineNeg30578;
                                            heapClassInst.heap32[r11 + numDefine162] = 0;
                                            heapClassInst.heap32[r11 + numDefine163] = 0;
                                            heapClassInst.heap32[r11 + numDefine164] = numDefineNeg99609;
                                            heapClassInst.heap32[r11 + numDefine165] = 0;
                                            heapClassInst.heap32[r11 + numDefine166] = 0;
                                            heapClassInst.heap8[r8 + numDefine720] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine721] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine723] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine724] = (byte) r4;
                                            heapClassInst.heap8[r8 + numDefine725] = (byte) r13;
                                            heapClassInst.heap32[r11 + numDefine183] = 0;
                                            heapClassInst.heap32[r11 + numDefine172] = numDefine53216;
                                            heapClassInst.heap32[r11 + numDefine173] = numDefineNeg30432;
                                            heapClassInst.heap32[r11 + numDefine170] = numDefine53722;
                                            heapClassInst.heap32[r11 + numDefine171] = numDefine53216;
                                            heapClassInst.heap32[r11 + numDefine169] = numDefine75494;
                                            heapClassInst.heap8[r8 + numDefine722] = (byte) r13;
                                            heapClassInst.heap32[r11 + numDefine179] = numDefine53216;
                                            heapClassInst.heap32[g0] = (int) numDefineNeg30853;
                                            heapClassInst.heap32[g0 + 1] = numDefine18619;
                                            fmodf(i7);
                                            f12 = commonVariable.fg0;
                                            f13 = numDefineNegFloat132;
                                            if (f12 >= f13) {
                                                f14 = numDefineFloat132;
                                                if (f12 > f14) {
                                                    f14 = numDefineNegFloat265;
                                                    f12 = f12 + f14;
                                                }
                                            } else {
                                                f14 = numDefineFloat265;
                                                f12 = f12 + f14;
                                            }
                                            r10 = r8 >> numDefine2;
                                            heapClassInst.heapFloat[r10 + numDefine172] = (float) f12;
                                            heapClassInst.heap32[g0] = numDefine41403;
                                            heapClassInst.heap32[g0 + 1] = numDefine18619;
                                            fmodf(i7);
                                            f12 = commonVariable.fg0;
                                            if (f12 >= f13) {
                                                f14 = numDefineFloat132;
                                                if (f12 > f14) {
                                                    f14 = numDefineNegFloat265;
                                                    f12 = f12 + f14;
                                                }
                                            } else {
                                                f14 = numDefineFloat265;
                                                f12 = f12 + f14;
                                            }
                                            heapClassInst.heapFloat[r10 + numDefine173] = (float) f12;
                                            heapClassInst.heap32[r10 + numDefine169] = numDefine75494;
                                            heapClassInst.heap32[r10 + numDefine170] = numDefine53722;
                                            heapClassInst.heap32[r10 + numDefine171] = numDefine53216;
                                            heapClassInst.heap32[r12 + numDefine24] = r8;
                                            r10 = heapClassInst.heap32[r12 + 1];
                                            r11 = r10 >> numDefine2;
                                            r11 = heapClassInst.heap32[r11];
                                            r11 = r11 >> numDefine2;
                                            r11 = heapClassInst.heap32[r11 + numDefine13];
                                            heapClassInst.heap32[g0] = r10;
                                            heapClassInst.heap32[g0 + 1] = r8;
                                            heapClassInst.heap32[g0 + numDefine2] = 1;
                                            functionTable.get(r11 >> numDefine2).accept(i7);
                                            heapClassInst.heap32[g0] = numDefine596;
                                            znwj(i7);
                                            r10 = heapClassInst.heap32[r12 + numDefine15];
                                            r11 = heapClassInst.heap32[r12 + numDefine14];
                                            r14 = commonVariable.rg0 >> numDefine2;
                                            heapClassInst.heap32[r14 + 1] = numDefine5;
                                            heapClassInst.heap32[r14 + numDefine2] = -1;
                                            heapClassInst.heap32[r14 + numDefine3] = -1;
                                            heapClassInst.heap8[commonVariable.rg0 + numDefine16] = (byte) r13;
                                            heapClassInst.heap32[r14 + numDefine5] = r11;
                                            heapClassInst.heap32[r14 + numDefine6] = r10;
                                            heapClassInst.heap32[r14 + numDefine7] = 0;
                                            r10 = ztv21btConeTwistConstraint;
                                            heapClassInst.heap32[r14 + numDefine8] = numDefine53722;
                                            r10 = (r10 + numDefine8) | 0;
                                            heapClassInst.heap32[r14] = r10;
                                            heapClassInst.heap32[r14 + numDefine72] = numDefineNeg30578;
                                            heapClassInst.heap32[r14 + numDefine73] = numDefineNeg30432;
                                            heapClassInst.heap32[r14 + numDefine74] = 0;
                                            heapClassInst.heap32[r14 + numDefine75] = 0;
                                            heapClassInst.heap32[r14 + numDefine76] = numDefine53216;
                                            heapClassInst.heap32[r14 + numDefine77] = numDefineNeg30578;
                                            heapClassInst.heap32[r14 + numDefine78] = 0;
                                            heapClassInst.heap32[r14 + numDefine79] = 0;
                                            heapClassInst.heap32[r14 + numDefine80] = numDefineNeg83648;
                                            heapClassInst.heap32[r14 + numDefine81] = 0;
                                            heapClassInst.heap32[r14 + numDefine82] = numDefine53216;
                                            heapClassInst.heap32[r14 + numDefine83] = 0;
                                            heapClassInst.heap32[r14 + numDefine84] = 0;
                                            heapClassInst.heap32[r14 + numDefine85] = numDefine72647;
                                            heapClassInst.heap32[r14 + numDefine86] = 0;
                                            heapClassInst.heap32[r14 + numDefine87] = 0;
                                            heapClassInst.heap32[r14 + numDefine88] = numDefineNeg30578;
                                            heapClassInst.heap32[r14 + numDefine89] = numDefineNeg30432;
                                            heapClassInst.heap32[r14 + numDefine90] = 0;
                                            heapClassInst.heap32[r14 + numDefine91] = 0;
                                            heapClassInst.heap32[r14 + numDefine92] = numDefine53216;
                                            heapClassInst.heap32[r14 + numDefine93] = numDefineNeg30578;
                                            heapClassInst.heap32[r14 + numDefine94] = 0;
                                            heapClassInst.heap32[r14 + numDefine95] = 0;
                                            heapClassInst.heap32[r14 + numDefine96] = numDefineNeg83648;
                                            heapClassInst.heap32[r14 + numDefine97] = 0;
                                            heapClassInst.heap32[r14 + numDefine98] = numDefine53216;
                                            heapClassInst.heap32[r14 + numDefine99] = 0;
                                            heapClassInst.heap32[r14 + numDefine100] = 0;
                                            heapClassInst.heap32[r14 + numDefine101] = numDefineNeg54584;
                                            heapClassInst.heap32[r14 + numDefine102] = 0;
                                            heapClassInst.heap32[r14 + numDefine103] = 0;
                                            heapClassInst.heap8[commonVariable.rg0 + numDefine540] = (byte) r13;
                                            heapClassInst.heap32[r14 + numDefine128] = 0;
                                            heapClassInst.heap32[r14 + numDefine140] = numDefineNeg30432;
                                            heapClassInst.heap32[r14 + numDefine107] = numDefine81770;
                                            heapClassInst.heap32[r14 + numDefine111] = numDefine43341;
                                            heapClassInst.heap32[r14 + numDefine145] = 0;
                                            heapClassInst.heap32[r14 + numDefine146] = 0;
                                            heapClassInst.heap32[r14 + numDefine147] = numDefine20051;
                                            heapClassInst.heap32[r14 + numDefine148] = 0;
                                            heapClassInst.heap32[r14 + numDefine108] = numDefine52795;
                                            heapClassInst.heap32[r14 + numDefine109] = numDefine52795;
                                            heapClassInst.heap32[r14 + numDefine110] = numDefine41403;
                                            heapClassInst.heap32[r14 + numDefine104] = numDefine53216;
                                            heapClassInst.heap32[r14 + numDefine105] = numDefine53722;
                                            heapClassInst.heap32[r14 + numDefine106] = numDefine53216;
                                            heapClassInst.heap32[r12 + numDefine25] = commonVariable.rg0;
                                            r11 = heapClassInst.heap32[r12 + 1];
                                            r14 = r11 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14];
                                            r14 = r14 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14 + numDefine13];
                                            heapClassInst.heap32[g0] = r11;
                                            heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
                                            heapClassInst.heap32[g0 + numDefine2] = 1;
                                            functionTable.get(r14 >> numDefine2).accept(i7);
                                            heapClassInst.heap32[g0] = numDefine596;
                                            znwj(i7);
                                            r11 = heapClassInst.heap32[r12 + numDefine16];
                                            r14 = heapClassInst.heap32[r12 + numDefine13];
                                            r15 = commonVariable.rg0 >> numDefine2;
                                            heapClassInst.heap32[r15 + 1] = numDefine5;
                                            heapClassInst.heap32[r15 + numDefine2] = -1;
                                            heapClassInst.heap32[r15 + numDefine3] = -1;
                                            heapClassInst.heap8[commonVariable.rg0 + numDefine16] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine5] = r14;
                                            heapClassInst.heap32[r15 + numDefine6] = r11;
                                            heapClassInst.heap32[r15 + numDefine7] = 0;
                                            heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                                            heapClassInst.heap32[r15] = r10;
                                            heapClassInst.heap32[r15 + numDefine72] = numDefineNeg44364;
                                            heapClassInst.heap32[r15 + numDefine73] = numDefineNeg44366;
                                            heapClassInst.heap32[r15 + numDefine74] = 0;
                                            heapClassInst.heap32[r15 + numDefine75] = 0;
                                            heapClassInst.heap32[r15 + numDefine76] = numDefine39282;
                                            heapClassInst.heap32[r15 + numDefine77] = numDefineNeg44364;
                                            heapClassInst.heap32[r15 + numDefine78] = 0;
                                            heapClassInst.heap32[r15 + numDefine79] = 0;
                                            heapClassInst.heap32[r15 + numDefine80] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine81] = 0;
                                            heapClassInst.heap32[r15 + numDefine82] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine83] = 0;
                                            heapClassInst.heap32[r15 + numDefine84] = numDefineNeg38002;
                                            heapClassInst.heap32[r15 + numDefine85] = numDefineNeg52205;
                                            heapClassInst.heap32[r15 + numDefine86] = 0;
                                            heapClassInst.heap32[r15 + numDefine87] = 0;
                                            heapClassInst.heap32[r15 + numDefine88] = numDefineNeg44364;
                                            heapClassInst.heap32[r15 + numDefine89] = numDefineNeg44366;
                                            heapClassInst.heap32[r15 + numDefine90] = 0;
                                            heapClassInst.heap32[r15 + numDefine91] = 0;
                                            heapClassInst.heap32[r15 + numDefine92] = numDefine39282;
                                            heapClassInst.heap32[r15 + numDefine93] = numDefineNeg44364;
                                            heapClassInst.heap32[r15 + numDefine94] = 0;
                                            heapClassInst.heap32[r15 + numDefine95] = 0;
                                            heapClassInst.heap32[r15 + numDefine96] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine97] = 0;
                                            heapClassInst.heap32[r15 + numDefine98] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine99] = 0;
                                            heapClassInst.heap32[r15 + numDefine100] = 0;
                                            heapClassInst.heap32[r15 + numDefine101] = numDefine88057;
                                            heapClassInst.heap32[r15 + numDefine102] = 0;
                                            heapClassInst.heap32[r15 + numDefine103] = 0;
                                            heapClassInst.heap8[commonVariable.rg0 + numDefine540] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine128] = 0;
                                            heapClassInst.heap32[r15 + numDefine140] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine107] = numDefine81770;
                                            heapClassInst.heap32[r15 + numDefine111] = numDefine43341;
                                            heapClassInst.heap32[r15 + numDefine145] = 0;
                                            heapClassInst.heap32[r15 + numDefine146] = 0;
                                            heapClassInst.heap32[r15 + numDefine147] = numDefine20051;
                                            heapClassInst.heap32[r15 + numDefine148] = 0;
                                            heapClassInst.heap32[r15 + numDefine108] = numDefine52795;
                                            heapClassInst.heap32[r15 + numDefine109] = numDefine52795;
                                            heapClassInst.heap32[r15 + numDefine110] = 0;
                                            heapClassInst.heap32[r15 + numDefine104] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine105] = numDefine53722;
                                            heapClassInst.heap32[r15 + numDefine106] = numDefine53216;
                                            heapClassInst.heap32[r12 + numDefine26] = commonVariable.rg0;
                                            r11 = heapClassInst.heap32[r12 + 1];
                                            r14 = r11 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14];
                                            r14 = r14 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14 + numDefine13];
                                            heapClassInst.heap32[g0] = r11;
                                            heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
                                            heapClassInst.heap32[g0 + numDefine2] = 1;
                                            functionTable.get(r14 >> numDefine2).accept(i7);
                                            heapClassInst.heap32[g0] = numDefine748;
                                            znwj(i7);
                                            r8 = commonVariable.rg0;
                                            r11 = heapClassInst.heap32[r12 + numDefine17];
                                            r14 = heapClassInst.heap32[r12 + numDefine16];
                                            r15 = r8 >> numDefine2;
                                            heapClassInst.heap32[r15 + 1] = numDefine4;
                                            heapClassInst.heap32[r15 + numDefine2] = -1;
                                            heapClassInst.heap32[r15 + numDefine3] = -1;
                                            heapClassInst.heap8[r8 + numDefine16] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine5] = r14;
                                            heapClassInst.heap32[r15 + numDefine6] = r11;
                                            heapClassInst.heap32[r15 + numDefine7] = 0;
                                            heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                                            heapClassInst.heap32[r15] = r9;
                                            heapClassInst.heap32[r15 + numDefine135] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine136] = 0;
                                            heapClassInst.heap32[r15 + numDefine137] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine138] = 0;
                                            heapClassInst.heap32[r15 + numDefine139] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine140] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine141] = 0;
                                            heapClassInst.heap32[r15 + numDefine142] = 0;
                                            heapClassInst.heap32[r15 + numDefine143] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine144] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine145] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine146] = 0;
                                            heapClassInst.heap32[r15 + numDefine147] = 0;
                                            heapClassInst.heap32[r15 + numDefine148] = numDefineNeg95591;
                                            heapClassInst.heap32[r15 + numDefine149] = 0;
                                            heapClassInst.heap32[r15 + numDefine150] = 0;
                                            heapClassInst.heap32[r15 + numDefine151] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine152] = 0;
                                            heapClassInst.heap32[r15 + numDefine153] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine154] = 0;
                                            heapClassInst.heap32[r15 + numDefine155] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine156] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine157] = 0;
                                            heapClassInst.heap32[r15 + numDefine158] = 0;
                                            heapClassInst.heap32[r15 + numDefine159] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine160] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine161] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine162] = 0;
                                            heapClassInst.heap32[r15 + numDefine163] = 0;
                                            heapClassInst.heap32[r15 + numDefine164] = numDefine39248;
                                            heapClassInst.heap32[r15 + numDefine165] = 0;
                                            heapClassInst.heap32[r15 + numDefine166] = 0;
                                            heapClassInst.heap8[r8 + numDefine720] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine721] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine723] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine724] = (byte) r4;
                                            heapClassInst.heap8[r8 + numDefine725] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine183] = 0;
                                            heapClassInst.heap32[r15 + numDefine172] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine173] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine170] = numDefine53722;
                                            heapClassInst.heap32[r15 + numDefine171] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine169] = numDefine75494;
                                            heapClassInst.heap8[r8 + numDefine722] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine179] = numDefine53216;
                                            heapClassInst.heap32[g0] = 0;
                                            heapClassInst.heap32[g0 + 1] = numDefine18619;
                                            fmodf(i7);
                                            f12 = commonVariable.fg0;
                                            if (f12 >= f13) {
                                                f14 = numDefineFloat132;
                                                if (f12 > f14) {
                                                    f14 = numDefineNegFloat265;
                                                    f12 = f12 + f14;
                                                }
                                            } else {
                                                f14 = numDefineFloat265;
                                                f12 = f12 + f14;
                                            }
                                            r11 = r8 >> numDefine2;
                                            heapClassInst.heapFloat[r11 + numDefine172] = (float) f12;
                                            heapClassInst.heap32[g0] = numDefine41403;
                                            heapClassInst.heap32[g0 + 1] = numDefine18619;
                                            fmodf(i7);
                                            f12 = commonVariable.fg0;
                                            if (f12 >= f13) {
                                                f14 = numDefineFloat132;
                                                if (f12 > f14) {
                                                    f14 = numDefineNegFloat265;
                                                    f12 = f12 + f14;
                                                }
                                            } else {
                                                f14 = numDefineFloat265;
                                                f12 = f12 + f14;
                                            }
                                            heapClassInst.heapFloat[r11 + numDefine173] = (float) f12;
                                            heapClassInst.heap32[r11 + numDefine169] = numDefine75494;
                                            heapClassInst.heap32[r11 + numDefine170] = numDefine53722;
                                            heapClassInst.heap32[r11 + numDefine171] = numDefine53216;
                                            heapClassInst.heap32[r12 + numDefine27] = r8;
                                            r11 = heapClassInst.heap32[r12 + 1];
                                            r14 = r11 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14];
                                            r14 = r14 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14 + numDefine13];
                                            heapClassInst.heap32[g0] = r11;
                                            heapClassInst.heap32[g0 + 1] = r8;
                                            heapClassInst.heap32[g0 + numDefine2] = 1;
                                            functionTable.get(r14 >> numDefine2).accept(i7);
                                            heapClassInst.heap32[g0] = numDefine596;
                                            znwj(i7);
                                            r11 = heapClassInst.heap32[r12 + numDefine18];
                                            r14 = heapClassInst.heap32[r12 + numDefine13];
                                            r15 = commonVariable.rg0 >> numDefine2;
                                            heapClassInst.heap32[r15 + 1] = numDefine5;
                                            heapClassInst.heap32[r15 + numDefine2] = -1;
                                            heapClassInst.heap32[r15 + numDefine3] = -1;
                                            heapClassInst.heap8[commonVariable.rg0 + numDefine16] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine5] = r14;
                                            heapClassInst.heap32[r15 + numDefine6] = r11;
                                            heapClassInst.heap32[r15 + numDefine7] = 0;
                                            heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                                            heapClassInst.heap32[r15] = r10;
                                            heapClassInst.heap32[r15 + numDefine72] = numDefine39283;
                                            heapClassInst.heap32[r15 + numDefine73] = numDefineNeg44365;
                                            heapClassInst.heap32[r15 + numDefine74] = 0;
                                            heapClassInst.heap32[r15 + numDefine75] = 0;
                                            heapClassInst.heap32[r15 + numDefine76] = numDefine39283;
                                            heapClassInst.heap32[r15 + numDefine77] = numDefine39283;
                                            heapClassInst.heap32[r15 + numDefine78] = 0;
                                            heapClassInst.heap32[r15 + numDefine79] = 0;
                                            heapClassInst.heap32[r15 + numDefine80] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine81] = 0;
                                            heapClassInst.heap32[r15 + numDefine82] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine83] = 0;
                                            heapClassInst.heap32[r15 + numDefine84] = numDefine45646;
                                            heapClassInst.heap32[r15 + numDefine85] = numDefineNeg52205;
                                            heapClassInst.heap32[r15 + numDefine86] = 0;
                                            heapClassInst.heap32[r15 + numDefine87] = 0;
                                            heapClassInst.heap32[r15 + numDefine88] = numDefine39283;
                                            heapClassInst.heap32[r15 + numDefine89] = numDefineNeg44365;
                                            heapClassInst.heap32[r15 + numDefine90] = 0;
                                            heapClassInst.heap32[r15 + numDefine91] = 0;
                                            heapClassInst.heap32[r15 + numDefine92] = numDefine39283;
                                            heapClassInst.heap32[r15 + numDefine93] = numDefine39283;
                                            heapClassInst.heap32[r15 + numDefine94] = 0;
                                            heapClassInst.heap32[r15 + numDefine95] = 0;
                                            heapClassInst.heap32[r15 + numDefine96] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine97] = 0;
                                            heapClassInst.heap32[r15 + numDefine98] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine99] = 0;
                                            heapClassInst.heap32[r15 + numDefine100] = 0;
                                            heapClassInst.heap32[r15 + numDefine101] = numDefine88057;
                                            heapClassInst.heap32[r15 + numDefine102] = 0;
                                            heapClassInst.heap32[r15 + numDefine103] = 0;
                                            heapClassInst.heap8[commonVariable.rg0 + numDefine540] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine128] = 0;
                                            heapClassInst.heap32[r15 + numDefine140] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine107] = numDefine81770;
                                            heapClassInst.heap32[r15 + numDefine111] = numDefine43341;
                                            heapClassInst.heap32[r15 + numDefine145] = 0;
                                            heapClassInst.heap32[r15 + numDefine146] = 0;
                                            heapClassInst.heap32[r15 + numDefine147] = numDefine20051;
                                            heapClassInst.heap32[r15 + numDefine148] = 0;
                                            heapClassInst.heap32[r15 + numDefine108] = numDefine52795;
                                            heapClassInst.heap32[r15 + numDefine109] = numDefine52795;
                                            heapClassInst.heap32[r15 + numDefine110] = 0;
                                            heapClassInst.heap32[r15 + numDefine104] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine105] = numDefine53722;
                                            heapClassInst.heap32[r15 + numDefine106] = numDefine53216;
                                            heapClassInst.heap32[r12 + numDefine28] = commonVariable.rg0;
                                            r11 = heapClassInst.heap32[r12 + 1];
                                            r14 = r11 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14];
                                            r14 = r14 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14 + numDefine13];
                                            heapClassInst.heap32[g0] = r11;
                                            heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
                                            heapClassInst.heap32[g0 + numDefine2] = 1;
                                            functionTable.get(r14 >> numDefine2).accept(i7);
                                            heapClassInst.heap32[g0] = numDefine748;
                                            znwj(i7);
                                            r8 = commonVariable.rg0;
                                            r11 = heapClassInst.heap32[r12 + numDefine19];
                                            r14 = heapClassInst.heap32[r12 + numDefine18];
                                            r15 = r8 >> numDefine2;
                                            heapClassInst.heap32[r15 + 1] = numDefine4;
                                            heapClassInst.heap32[r15 + numDefine2] = -1;
                                            heapClassInst.heap32[r15 + numDefine3] = -1;
                                            heapClassInst.heap8[r8 + numDefine16] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine5] = r14;
                                            heapClassInst.heap32[r15 + numDefine6] = r11;
                                            heapClassInst.heap32[r15 + numDefine7] = 0;
                                            heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                                            heapClassInst.heap32[r15] = r9;
                                            heapClassInst.heap32[r15 + numDefine135] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine136] = 0;
                                            heapClassInst.heap32[r15 + numDefine137] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine138] = 0;
                                            heapClassInst.heap32[r15 + numDefine139] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine140] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine141] = 0;
                                            heapClassInst.heap32[r15 + numDefine142] = 0;
                                            heapClassInst.heap32[r15 + numDefine143] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine144] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine145] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine146] = 0;
                                            heapClassInst.heap32[r15 + numDefine147] = 0;
                                            heapClassInst.heap32[r15 + numDefine148] = numDefineNeg95591;
                                            heapClassInst.heap32[r15 + numDefine149] = 0;
                                            heapClassInst.heap32[r15 + numDefine150] = 0;
                                            heapClassInst.heap32[r15 + numDefine151] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine152] = 0;
                                            heapClassInst.heap32[r15 + numDefine153] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine154] = 0;
                                            heapClassInst.heap32[r15 + numDefine155] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine156] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine157] = 0;
                                            heapClassInst.heap32[r15 + numDefine158] = 0;
                                            heapClassInst.heap32[r15 + numDefine159] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine160] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine161] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine162] = 0;
                                            heapClassInst.heap32[r15 + numDefine163] = 0;
                                            heapClassInst.heap32[r15 + numDefine164] = numDefine39248;
                                            heapClassInst.heap32[r15 + numDefine165] = 0;
                                            heapClassInst.heap32[r15 + numDefine166] = 0;
                                            heapClassInst.heap8[r8 + numDefine720] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine721] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine723] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine724] = (byte) r4;
                                            heapClassInst.heap8[r8 + numDefine725] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine183] = 0;
                                            heapClassInst.heap32[r15 + numDefine172] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine173] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine170] = numDefine53722;
                                            heapClassInst.heap32[r15 + numDefine171] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine169] = numDefine75494;
                                            heapClassInst.heap8[r8 + numDefine722] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine179] = numDefine53216;
                                            heapClassInst.heap32[g0] = 0;
                                            heapClassInst.heap32[g0 + 1] = numDefine18619;
                                            fmodf(i7);
                                            f12 = commonVariable.fg0;
                                            if (f12 >= f13) {
                                                f14 = numDefineFloat132;
                                                if (f12 > f14) {
                                                    f14 = numDefineNegFloat265;
                                                    f12 = f12 + f14;
                                                }
                                            } else {
                                                f14 = numDefineFloat265;
                                                f12 = f12 + f14;
                                            }
                                            r11 = r8 >> numDefine2;
                                            heapClassInst.heapFloat[r11 + numDefine172] = (float) f12;
                                            heapClassInst.heap32[g0] = numDefine41403;
                                            heapClassInst.heap32[g0 + 1] = numDefine18619;
                                            fmodf(i7);
                                            f12 = commonVariable.fg0;
                                            if (f12 >= f13) {
                                                f14 = numDefineFloat132;
                                                if (f12 > f14) {
                                                    f14 = numDefineNegFloat265;
                                                    f12 = f12 + f14;
                                                }
                                            } else {
                                                f14 = numDefineFloat265;
                                                f12 = f12 + f14;
                                            }
                                            heapClassInst.heapFloat[r11 + numDefine173] = (float) f12;
                                            heapClassInst.heap32[r11 + numDefine169] = numDefine75494;
                                            heapClassInst.heap32[r11 + numDefine170] = numDefine53722;
                                            heapClassInst.heap32[r11 + numDefine171] = numDefine53216;
                                            heapClassInst.heap32[r12 + numDefine29] = r8;
                                            r11 = heapClassInst.heap32[r12 + 1];
                                            r14 = r11 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14];
                                            r14 = r14 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14 + numDefine13];
                                            heapClassInst.heap32[g0] = r11;
                                            heapClassInst.heap32[g0 + 1] = r8;
                                            heapClassInst.heap32[g0 + numDefine2] = 1;
                                            functionTable.get(r14 >> numDefine2).accept(i7);
                                            heapClassInst.heap32[g0] = numDefine596;
                                            znwj(i7);
                                            r11 = heapClassInst.heap32[r12 + numDefine20];
                                            r14 = heapClassInst.heap32[r12 + numDefine14];
                                            r15 = commonVariable.rg0 >> numDefine2;
                                            heapClassInst.heap32[r15 + 1] = numDefine5;
                                            heapClassInst.heap32[r15 + numDefine2] = -1;
                                            heapClassInst.heap32[r15 + numDefine3] = -1;
                                            heapClassInst.heap8[commonVariable.rg0 + numDefine16] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine5] = r14;
                                            heapClassInst.heap32[r15 + numDefine6] = r11;
                                            heapClassInst.heap32[r15 + numDefine7] = 0;
                                            heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                                            heapClassInst.heap32[r15] = r10;
                                            heapClassInst.heap32[r15 + numDefine72] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine73] = numDefine41678;
                                            heapClassInst.heap32[r15 + numDefine74] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine75] = 0;
                                            heapClassInst.heap32[r15 + numDefine76] = numDefineNeg41970;
                                            heapClassInst.heap32[r15 + numDefine77] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine78] = 0;
                                            heapClassInst.heap32[r15 + numDefine79] = 0;
                                            heapClassInst.heap32[r15 + numDefine80] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine81] = 0;
                                            heapClassInst.heap32[r15 + numDefine82] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine83] = 0;
                                            heapClassInst.heap32[r15 + numDefine84] = numDefineNeg63597;
                                            heapClassInst.heap32[r15 + numDefine85] = numDefine84039;
                                            heapClassInst.heap32[r15 + numDefine86] = 0;
                                            heapClassInst.heap32[r15 + numDefine87] = 0;
                                            heapClassInst.heap32[r15 + numDefine88] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine89] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine90] = 0;
                                            heapClassInst.heap32[r15 + numDefine91] = 0;
                                            heapClassInst.heap32[r15 + numDefine92] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine93] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine94] = 0;
                                            heapClassInst.heap32[r15 + numDefine95] = 0;
                                            heapClassInst.heap32[r15 + numDefine96] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine97] = 0;
                                            heapClassInst.heap32[r15 + numDefine98] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine99] = 0;
                                            heapClassInst.heap32[r15 + numDefine100] = 0;
                                            heapClassInst.heap32[r15 + numDefine101] = numDefineNeg38002;
                                            heapClassInst.heap32[r15 + numDefine102] = 0;
                                            heapClassInst.heap32[r15 + numDefine103] = 0;
                                            heapClassInst.heap8[commonVariable.rg0 + numDefine540] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine128] = 0;
                                            heapClassInst.heap32[r15 + numDefine140] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine107] = numDefine81770;
                                            heapClassInst.heap32[r15 + numDefine111] = numDefine43341;
                                            heapClassInst.heap32[r15 + numDefine145] = 0;
                                            heapClassInst.heap32[r15 + numDefine146] = 0;
                                            heapClassInst.heap32[r15 + numDefine147] = numDefine20051;
                                            heapClassInst.heap32[r15 + numDefine148] = 0;
                                            heapClassInst.heap32[r15 + numDefine108] = numDefine41403;
                                            heapClassInst.heap32[r15 + numDefine109] = numDefine41403;
                                            heapClassInst.heap32[r15 + numDefine110] = 0;
                                            heapClassInst.heap32[r15 + numDefine104] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine105] = numDefine53722;
                                            heapClassInst.heap32[r15 + numDefine106] = numDefine53216;
                                            heapClassInst.heap32[r12 + numDefine30] = commonVariable.rg0;
                                            r11 = heapClassInst.heap32[r12 + 1];
                                            r14 = r11 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14];
                                            r14 = r14 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14 + numDefine13];
                                            heapClassInst.heap32[g0] = r11;
                                            heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
                                            heapClassInst.heap32[g0 + numDefine2] = 1;
                                            functionTable.get(r14 >> numDefine2).accept(i7);
                                            heapClassInst.heap32[g0] = numDefine748;
                                            znwj(i7);
                                            r8 = commonVariable.rg0;
                                            r11 = heapClassInst.heap32[r12 + numDefine21];
                                            r14 = heapClassInst.heap32[r12 + numDefine20];
                                            r15 = r8 >> numDefine2;
                                            heapClassInst.heap32[r15 + 1] = numDefine4;
                                            heapClassInst.heap32[r15 + numDefine2] = -1;
                                            heapClassInst.heap32[r15 + numDefine3] = -1;
                                            heapClassInst.heap8[r8 + numDefine16] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine5] = r14;
                                            heapClassInst.heap32[r15 + numDefine6] = r11;
                                            heapClassInst.heap32[r15 + numDefine7] = 0;
                                            heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                                            heapClassInst.heap32[r15] = r9;
                                            heapClassInst.heap32[r15 + numDefine135] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine136] = 0;
                                            heapClassInst.heap32[r15 + numDefine137] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine138] = 0;
                                            heapClassInst.heap32[r15 + numDefine139] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine140] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine141] = 0;
                                            heapClassInst.heap32[r15 + numDefine142] = 0;
                                            heapClassInst.heap32[r15 + numDefine143] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine144] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine145] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine146] = 0;
                                            heapClassInst.heap32[r15 + numDefine147] = 0;
                                            heapClassInst.heap32[r15 + numDefine148] = numDefine45646;
                                            heapClassInst.heap32[r15 + numDefine149] = 0;
                                            heapClassInst.heap32[r15 + numDefine150] = 0;
                                            heapClassInst.heap32[r15 + numDefine151] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine152] = 0;
                                            heapClassInst.heap32[r15 + numDefine153] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine154] = 0;
                                            heapClassInst.heap32[r15 + numDefine155] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine156] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine157] = 0;
                                            heapClassInst.heap32[r15 + numDefine158] = 0;
                                            heapClassInst.heap32[r15 + numDefine159] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine160] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine161] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine162] = 0;
                                            heapClassInst.heap32[r15 + numDefine163] = 0;
                                            heapClassInst.heap32[r15 + numDefine164] = numDefineNeg54584;
                                            heapClassInst.heap32[r15 + numDefine165] = 0;
                                            heapClassInst.heap32[r15 + numDefine166] = 0;
                                            heapClassInst.heap8[r8 + numDefine720] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine721] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine723] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine724] = (byte) r4;
                                            heapClassInst.heap8[r8 + numDefine725] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine183] = 0;
                                            heapClassInst.heap32[r15 + numDefine172] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine173] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine170] = numDefine53722;
                                            heapClassInst.heap32[r15 + numDefine171] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine169] = numDefine75494;
                                            heapClassInst.heap8[r8 + numDefine722] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine179] = numDefine53216;
                                            heapClassInst.heap32[g0] = numDefineNeg42245;
                                            heapClassInst.heap32[g0 + 1] = numDefine18619;
                                            fmodf(i7);
                                            f12 = commonVariable.fg0;
                                            if (f12 >= f13) {
                                                f14 = numDefineFloat132;
                                                if (f12 > f14) {
                                                    f14 = numDefineNegFloat265;
                                                    f12 = f12 + f14;
                                                }
                                            } else {
                                                f14 = numDefineFloat265;
                                                f12 = f12 + f14;
                                            }
                                            r11 = r8 >> numDefine2;
                                            heapClassInst.heapFloat[r11 + numDefine172] = (float) f12;
                                            heapClassInst.heap32[g0] = 0;
                                            heapClassInst.heap32[g0 + 1] = numDefine18619;
                                            fmodf(i7);
                                            f12 = commonVariable.fg0;
                                            if (f12 >= f13) {
                                                f14 = numDefineFloat132;
                                                if (f12 > f14) {
                                                    f14 = numDefineNegFloat265;
                                                    f12 = f12 + f14;
                                                }
                                            } else {
                                                f14 = numDefineFloat265;
                                                f12 = f12 + f14;
                                            }
                                            heapClassInst.heapFloat[r11 + numDefine173] = (float) f12;
                                            heapClassInst.heap32[r11 + numDefine169] = numDefine75494;
                                            heapClassInst.heap32[r11 + numDefine170] = numDefine53722;
                                            heapClassInst.heap32[r11 + numDefine171] = numDefine53216;
                                            heapClassInst.heap32[r12 + numDefine31] = r8;
                                            r11 = heapClassInst.heap32[r12 + 1];
                                            r14 = r11 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14];
                                            r14 = r14 >> numDefine2;
                                            r14 = heapClassInst.heap32[r14 + numDefine13];
                                            heapClassInst.heap32[g0] = r11;
                                            heapClassInst.heap32[g0 + 1] = r8;
                                            heapClassInst.heap32[g0 + numDefine2] = 1;
                                            functionTable.get(r14 >> numDefine2).accept(i7);
                                            heapClassInst.heap32[g0] = numDefine596;
                                            znwj(i7);
                                            r11 = heapClassInst.heap32[r12 + numDefine22];
                                            r14 = heapClassInst.heap32[r12 + numDefine14];
                                            r15 = commonVariable.rg0 >> numDefine2;
                                            heapClassInst.heap32[r15 + 1] = numDefine5;
                                            heapClassInst.heap32[r15 + numDefine2] = -1;
                                            heapClassInst.heap32[r15 + numDefine3] = -1;
                                            heapClassInst.heap8[commonVariable.rg0 + numDefine16] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine5] = r14;
                                            heapClassInst.heap32[r15 + numDefine6] = r11;
                                            heapClassInst.heap32[r15 + numDefine7] = 0;
                                            heapClassInst.heap32[r15 + numDefine8] = numDefine53722;
                                            heapClassInst.heap32[r15] = r10;
                                            heapClassInst.heap32[r15 + numDefine72] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine73] = 0;
                                            heapClassInst.heap32[r15 + numDefine74] = 0;
                                            heapClassInst.heap32[r15 + numDefine75] = 0;
                                            heapClassInst.heap32[r15 + numDefine76] = 0;
                                            heapClassInst.heap32[r15 + numDefine77] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine78] = 0;
                                            heapClassInst.heap32[r15 + numDefine79] = 0;
                                            heapClassInst.heap32[r15 + numDefine80] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine81] = 0;
                                            heapClassInst.heap32[r15 + numDefine82] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine83] = 0;
                                            heapClassInst.heap32[r15 + numDefine84] = numDefine20051;
                                            heapClassInst.heap32[r15 + numDefine85] = numDefine84039;
                                            heapClassInst.heap32[r15 + numDefine86] = 0;
                                            heapClassInst.heap32[r15 + numDefine87] = 0;
                                            heapClassInst.heap32[r15 + numDefine88] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine89] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine90] = 0;
                                            heapClassInst.heap32[r15 + numDefine91] = 0;
                                            heapClassInst.heap32[r15 + numDefine92] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine93] = numDefineNeg30578;
                                            heapClassInst.heap32[r15 + numDefine94] = 0;
                                            heapClassInst.heap32[r15 + numDefine95] = 0;
                                            heapClassInst.heap32[r15 + numDefine96] = numDefineNeg83648;
                                            heapClassInst.heap32[r15 + numDefine97] = 0;
                                            heapClassInst.heap32[r15 + numDefine98] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine99] = 0;
                                            heapClassInst.heap32[r15 + numDefine100] = 0;
                                            heapClassInst.heap32[r15 + numDefine101] = numDefineNeg38002;
                                            heapClassInst.heap32[r15 + numDefine102] = 0;
                                            heapClassInst.heap32[r15 + numDefine103] = 0;
                                            heapClassInst.heap8[commonVariable.rg0 + numDefine540] = (byte) r13;
                                            heapClassInst.heap32[r15 + numDefine128] = 0;
                                            heapClassInst.heap32[r15 + numDefine140] = numDefineNeg30432;
                                            heapClassInst.heap32[r15 + numDefine107] = numDefine81770;
                                            heapClassInst.heap32[r15 + numDefine111] = numDefine43341;
                                            heapClassInst.heap32[r15 + numDefine145] = 0;
                                            heapClassInst.heap32[r15 + numDefine146] = 0;
                                            heapClassInst.heap32[r15 + numDefine147] = numDefine20051;
                                            heapClassInst.heap32[r15 + numDefine148] = 0;
                                            heapClassInst.heap32[r15 + numDefine108] = numDefine41403;
                                            heapClassInst.heap32[r15 + numDefine109] = numDefine41403;
                                            heapClassInst.heap32[r15 + numDefine110] = 0;
                                            heapClassInst.heap32[r15 + numDefine104] = numDefine53216;
                                            heapClassInst.heap32[r15 + numDefine105] = numDefine53722;
                                            heapClassInst.heap32[r15 + numDefine106] = numDefine53216;
                                            heapClassInst.heap32[r12 + numDefine32] = commonVariable.rg0;
                                            r10 = heapClassInst.heap32[r12 + 1];
                                            r11 = r10 >> numDefine2;
                                            r11 = heapClassInst.heap32[r11];
                                            r11 = r11 >> numDefine2;
                                            r11 = heapClassInst.heap32[r11 + numDefine13];
                                            heapClassInst.heap32[g0] = r10;
                                            heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
                                            heapClassInst.heap32[g0 + numDefine2] = 1;
                                            functionTable.get(r11 >> numDefine2).accept(i7);
                                            heapClassInst.heap32[g0] = numDefine748;
                                            znwj(i7);
                                            r8 = commonVariable.rg0;
                                            r10 = heapClassInst.heap32[r12 + numDefine23];
                                            r11 = heapClassInst.heap32[r12 + numDefine22];
                                            r14 = r8 >> numDefine2;
                                            heapClassInst.heap32[r14 + 1] = numDefine4;
                                            heapClassInst.heap32[r14 + numDefine2] = -1;
                                            heapClassInst.heap32[r14 + numDefine3] = -1;
                                            heapClassInst.heap8[r8 + numDefine16] = (byte) r13;
                                            heapClassInst.heap32[r14 + numDefine5] = r11;
                                            heapClassInst.heap32[r14 + numDefine6] = r10;
                                            heapClassInst.heap32[r14 + numDefine7] = 0;
                                            heapClassInst.heap32[r14 + numDefine8] = numDefine53722;
                                            heapClassInst.heap32[r14] = r9;
                                            heapClassInst.heap32[r14 + numDefine135] = numDefineNeg30578;
                                            heapClassInst.heap32[r14 + numDefine136] = 0;
                                            heapClassInst.heap32[r14 + numDefine137] = numDefine53216;
                                            heapClassInst.heap32[r14 + numDefine138] = 0;
                                            heapClassInst.heap32[r14 + numDefine139] = numDefineNeg83648;
                                            heapClassInst.heap32[r14 + numDefine140] = numDefine53216;
                                            heapClassInst.heap32[r14 + numDefine141] = 0;
                                            heapClassInst.heap32[r14 + numDefine142] = 0;
                                            heapClassInst.heap32[r14 + numDefine143] = numDefineNeg30432;
                                            heapClassInst.heap32[r14 + numDefine144] = numDefineNeg83648;
                                            heapClassInst.heap32[r14 + numDefine145] = numDefineNeg30578;
                                            heapClassInst.heap32[r14 + numDefine146] = 0;
                                            heapClassInst.heap32[r14 + numDefine147] = 0;
                                            heapClassInst.heap32[r14 + numDefine148] = numDefine45646;
                                            heapClassInst.heap32[r14 + numDefine149] = 0;
                                            heapClassInst.heap32[r14 + numDefine150] = 0;
                                            heapClassInst.heap32[r14 + numDefine151] = numDefineNeg30578;
                                            heapClassInst.heap32[r14 + numDefine152] = 0;
                                            heapClassInst.heap32[r14 + numDefine153] = numDefine53216;
                                            heapClassInst.heap32[r14 + numDefine154] = 0;
                                            heapClassInst.heap32[r14 + numDefine155] = numDefineNeg83648;
                                            heapClassInst.heap32[r14 + numDefine156] = numDefine53216;
                                            heapClassInst.heap32[r14 + numDefine157] = 0;
                                            heapClassInst.heap32[r14 + numDefine158] = 0;
                                            heapClassInst.heap32[r14 + numDefine159] = numDefineNeg30432;
                                            heapClassInst.heap32[r14 + numDefine160] = numDefineNeg83648;
                                            heapClassInst.heap32[r14 + numDefine161] = numDefineNeg30578;
                                            heapClassInst.heap32[r14 + numDefine162] = 0;
                                            heapClassInst.heap32[r14 + numDefine163] = 0;
                                            heapClassInst.heap32[r14 + numDefine164] = numDefineNeg54584;
                                            heapClassInst.heap32[r14 + numDefine165] = 0;
                                            heapClassInst.heap32[r14 + numDefine166] = 0;
                                            heapClassInst.heap8[r8 + numDefine720] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine721] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine723] = (byte) r13;
                                            heapClassInst.heap8[r8 + numDefine724] = (byte) r4;
                                            heapClassInst.heap8[r8 + numDefine725] = (byte) r13;
                                            heapClassInst.heap32[r14 + numDefine183] = 0;
                                            heapClassInst.heap32[r14 + numDefine172] = numDefine53216;
                                            heapClassInst.heap32[r14 + numDefine173] = numDefineNeg30432;
                                            heapClassInst.heap32[r14 + numDefine170] = numDefine53722;
                                            heapClassInst.heap32[r14 + numDefine171] = numDefine53216;
                                            heapClassInst.heap32[r14 + numDefine169] = numDefine75494;
                                            heapClassInst.heap8[r8 + numDefine722] = (byte) r13;
                                            heapClassInst.heap32[r14 + numDefine179] = numDefine53216;
                                            heapClassInst.heap32[g0] = numDefineNeg42245;
                                            heapClassInst.heap32[g0 + 1] = numDefine18619;
                                            fmodf(i7);
                                            f12 = commonVariable.fg0;
                                            if (f12 >= f13) {
                                                f14 = numDefineFloat132;
                                                if (f12 > f14) {
                                                    f14 = numDefineNegFloat265;
                                                    f12 = f12 + f14;
                                                }
                                            } else {
                                                f14 = numDefineFloat265;
                                                f12 = f12 + f14;
                                            }
                                            r9 = r8 >> numDefine2;
                                            heapClassInst.heapFloat[r9 + numDefine172] = (float) f12;
                                            heapClassInst.heap32[g0] = 0;
                                            heapClassInst.heap32[g0 + 1] = numDefine18619;
                                            fmodf(i7);
                                            f12 = commonVariable.fg0;
                                            if (f12 >= f13) {
                                                f13 = numDefineFloat132;
                                                if (f12 > f13) {
                                                    f13 = numDefineNegFloat265;
                                                    f12 = f12 + f13;
                                                }
                                            } else {
                                                f13 = numDefineFloat265;
                                                f12 = f12 + f13;
                                            }
                                            heapClassInst.heapFloat[r9 + numDefine173] = (float) f12;
                                            heapClassInst.heap32[r9 + numDefine169] = numDefine75494;
                                            heapClassInst.heap32[r9 + numDefine170] = numDefine53722;
                                            heapClassInst.heap32[r9 + numDefine171] = numDefine53216;
                                            heapClassInst.heap32[r12 + numDefine33] = r8;
                                            r9 = heapClassInst.heap32[r12 + 1];
                                            r10 = r9 >> numDefine2;
                                            r10 = heapClassInst.heap32[r10];
                                            r10 = r10 >> numDefine2;
                                            r10 = heapClassInst.heap32[r10 + numDefine13];
                                            heapClassInst.heap32[g0] = r9;
                                            heapClassInst.heap32[g0 + 1] = r8;
                                            heapClassInst.heap32[g0 + numDefine2] = 1;
                                            functionTable.get(r10 >> numDefine2).accept(i7);
                                            r8 = heapClassInst.heap32[r1 + numDefine10];
                                            r9 = heapClassInst.heap32[r1 + numDefine9];
                                            if (r8 == r9) {
                                                r10 = r9 << 1;
                                                r10 = r9 == 0 ? r4 : r10;
                                                if (!(r8 >= r10)) {
                                                    if (r10 != 0) {
                                                        r8 = heapClassInst.heap32[r2];
                                                        r11 = r10 << numDefine2;
                                                        r8 = (r8 + 1) | 0;
                                                        r11 = r11 | numDefine3;
                                                        heapClassInst.heap32[r2] = r8;
                                                        r8 = (r11 + numDefine16) | 0;
                                                        heapClassInst.heap32[g0] = r8;
                                                        mallocNew(i7);
                                                        r8 = commonVariable.rg0;
                                                        if (r8 != 0) {
                                                            r11 = (r8 + numDefine4) | 0;
                                                            r11 = (r13 - r11) | 0;
                                                            r11 = r11 & numDefine15;
                                                            r11 = (r8 + r11) | 0;
                                                            r12 = (r11 + numDefine4) | 0;
                                                            r11 = r11 >> numDefine2;
                                                            heapClassInst.heap32[r11] = r8;
                                                            r8 = r12;
                                                        }
                                                    } else {
                                                        r8 = 0;
                                                    }
                                                    repeat358:
                                                    do {
                                                        if (r9 < 1) {
                                                            r11 = heapClassInst.heap32[r1 + numDefine11];
                                                        } else {
                                                            while (true) {
                                                                r11 = heapClassInst.heap32[r1 + numDefine11];
                                                                r12 = r13 << numDefine2;
                                                                r14 = (r11 + r12) | 0;
                                                                r14 = r14 >> numDefine2;
                                                                r12 = (r8 + r12) | 0;
                                                                r14 = heapClassInst.heap32[r14];
                                                                r13 = (r13 + 1) | 0;
                                                                r12 = r12 >> numDefine2;
                                                                heapClassInst.heap32[r12] = r14;
                                                                if (!(r9 != r13)) {
                                                                    break repeat358;
                                                                }
                                                            }
                                                        }
                                                    } while (false);
                                                    if (r11 != 0) {
                                                        r12 = heapClassInst.heapU8[r6 + numDefine48];
                                                        if (r12 != 0) {
                                                            r9 = gNumAlignedFree;
                                                            r9 = r9 >> numDefine2;
                                                            r12 = heapClassInst.heap32[r9];
                                                            r12 = (r12 + 1) | 0;
                                                            r11 = r11 >> numDefine2;
                                                            heapClassInst.heap32[r9] = r12;
                                                            r9 = heapClassInst.heap32[r11 + -1];
                                                            heapClassInst.heap32[g0] = r9;
                                                            free(i7);
                                                            r9 = heapClassInst.heap32[r1 + numDefine9];
                                                        }
                                                        heapClassInst.heap32[r1 + numDefine11] = 0;
                                                    }
                                                    heapClassInst.heap8[r6 + numDefine48] = (byte) r4;
                                                    heapClassInst.heap32[r1 + numDefine11] = r8;
                                                    heapClassInst.heap32[r1 + numDefine10] = r10;
                                                }
                                            }
                                            r8 = r9 << numDefine2;
                                            r9 = heapClassInst.heap32[r1 + numDefine11];
                                            r8 = (r9 + r8) | 0;
                                            r8 = r8 >> numDefine2;
                                            heapClassInst.heap32[r8] = r7;
                                            r7 = heapClassInst.heap32[r1 + numDefine9];
                                            r5 = (r5 + 1) | 0;
                                            r7 = (r7 + 1) | 0;
                                            heapClassInst.heap32[r1 + numDefine9] = r7;
                                            if (!(r0 != r5)) {
                                                break repeat262;
                                            }
                                        }
                                        f3 = numDefine7;
                                        f4 = numDefineNeg2;
                                        r0 = (r0 + -1) | 0;
                                        f1 = f1 + f3;
                                        f2 = f2 + f4;
                                        r3 = (r3 + 1) | 0;
                                        if (r0 == 0) {
                                            break repeat161;
                                        } else {
                                            continue repeat260;
                                        }
                                    }
                                }
                            }
                        }
                    }
                } while (false);
                return;
            case numDefine46:
                r0 = twoEStr674;
                r1 = twoEStr573;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine53;
                assertNew(i7);
                break;
            default:
                break;
        }
    }

    public static void globalDz6mymainiPPc(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = zl14benchmarkDemo4;
        r1 = ztv13BenchmarkDemo;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zn13BenchmarkDemo11exitPhysicsEv(i7);
        r1 = heapClassInst.heap32[r2 + numDefine11];
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine48];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine11] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine48] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine11] = 0;
        heapClassInst.heap32[r2 + numDefine9] = 0;
        heapClassInst.heap32[r2 + numDefine10] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine6];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine28];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine6] = 0;
        }
        heapClassInst.heap8[r0 + numDefine28] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine6] = 0;
        heapClassInst.heap32[r2 + numDefine4] = 0;
        heapClassInst.heap32[r2 + numDefine5] = 0;

    }

    public static void zn14BenchmarkDemo4D1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv14BenchmarkDemo4;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zn13BenchmarkDemoD2Ev(i7);

    }

    public static void zn14BenchmarkDemo4D0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv14BenchmarkDemo4;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zn13BenchmarkDemoD2Ev(i7);
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);

    }

    public static void draw(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = zl14benchmarkDemo4;
        heapClassInst.heap32[g0] = r0;
        zn13BenchmarkDemo20clientMoveAndDisplayEv(i7);
        return;
    }

    public static void zn13BenchmarkDemoD2Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv13BenchmarkDemo;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zn13BenchmarkDemo11exitPhysicsEv(i7);
        r1 = heapClassInst.heap32[r2 + numDefine11];
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine48];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine11] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine48] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine11] = 0;
        heapClassInst.heap32[r2 + numDefine9] = 0;
        heapClassInst.heap32[r2 + numDefine10] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine6];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine28];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine6] = 0;
        }
        heapClassInst.heap8[r0 + numDefine28] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine6] = 0;
        heapClassInst.heap32[r2 + numDefine4] = 0;
        heapClassInst.heap32[r2 + numDefine5] = 0;
        return;
    }

    public static void initNew(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = gDisableDeactivation;
        r1 = 1;
        heapClassInst.heap8[r0] = (byte) r1;
        zn13BenchmarkDemo11initPhysicsEv(i7);
        return;
    }

    public static void zn15btNullPairCache23getOverlappingPairArrayEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = (r0 + numDefine4) | 0;
        commonVariable.rg0 = r0;

    }

    public static void zn15btNullPairCache20cleanOverlappingPairER16btBroadphasePairP12btDispatcher(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;

    }

    public static void znk15btNullPairCache22getNumOverlappingPairsEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = 0;
        commonVariable.rg0 = r0;

    }

    public static void zn15btNullPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcher(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;

    }

    public static void zn15btNullPairCache24setOverlapFilterCallbackEP23btOverlapFilterCallback(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;

    }

    public static void zn15btNullPairCache26processAllOverlappingPairsEP17btOverlapCallbackP12btDispatcher(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;

    }

    public static void zn15btNullPairCache8findPairEP17btBroadphaseProxyS1(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = 0;
        commonVariable.rg0 = r0;

    }

    public static void zn15btNullPairCache18hasDeferredRemovalEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = 1;
        commonVariable.rg0 = r0;

    }

    public static void zn15btNullPairCache28setInternalGhostPairCallbackEP25btOverlappingPairCallback(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;

    }

    public static void zn15btNullPairCache18addOverlappingPairEP17btBroadphaseProxyS1(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = 0;
        commonVariable.rg0 = r0;
        return;
    }

    public static void zn15btNullPairCache21removeOverlappingPairEP17btBroadphaseProxyS1P12btDispatcher(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = 0;
        commonVariable.rg0 = r0;

    }

    public static void zn15btNullPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcher(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;

    }

    public static void zn15btNullPairCache20sortOverlappingPairsEP12btDispatcher(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;

    }

    public static void zn15btNullPairCache26getOverlappingPairArrayPtrEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine4];
        commonVariable.rg0 = r0;

    }

    public static void znk15btNullPairCache26getOverlappingPairArrayPtrEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine4];
        commonVariable.rg0 = r0;

    }

    public static void zn15btNullPairCacheD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv15btNullPairCache;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine20];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine4] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine20] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine4] = 0;
        heapClassInst.heap32[r2 + numDefine2] = 0;
        heapClassInst.heap32[r2 + numDefine3] = 0;

    }

    public static void zn15btNullPairCacheD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv15btNullPairCache;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine20];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine4] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine20] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine4] = 0;
        heapClassInst.heap32[r2 + numDefine2] = 0;
        heapClassInst.heap32[r2 + numDefine3] = 0;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);

    }

    public static void znk20btAxisSweep3InternalItE7getAabbEP17btBroadphaseProxyR9btVector3S4(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp + numDefine2];
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r1] = heapClassInst.heap32[r0 + numDefine4];
        heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + numDefine5];
        r2 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine2];
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
        heapClassInst.heap32[r2] = heapClassInst.heap32[r0 + numDefine8];
        heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r0 + numDefine9];
        heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r0 + numDefine10];
        heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r0 + numDefine11];

    }

    public static void zn20btAxisSweep3InternalItE23getOverlappingPairCacheEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine23];
        commonVariable.rg0 = r0;

    }

    public static void znk20btAxisSweep3InternalItE23getOverlappingPairCacheEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine23];
        commonVariable.rg0 = r0;

    }

    public static void znk20btAxisSweep3InternalItE17getBroadphaseAabbER9btVector3S2(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r1] = heapClassInst.heap32[r0 + numDefine2];
        heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + numDefine3];
        r2 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine2];
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
        heapClassInst.heap32[r2] = heapClassInst.heap32[r0 + numDefine6];
        heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r0 + numDefine7];
        heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r0 + numDefine2];
        heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];

    }

    public static void zn20btAxisSweep3InternalItE9resetPoolEP12btDispatcher(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
        if (!(r1 != 0)) {
            r1 = 1;
            heapClassInst.heap16[(r0 + numDefine64) >> 1] = (short) r1;
            r2 = heapClassInst.heapU16[(r0 + numDefine58) >> 1];
            if (uint(r2) > uint(1)) {
                r3 = numDefine2;
                repeat5:
                while (true) {
                    r2 = r1 & numDefine65535;
                    r4 = r0 >> numDefine2;
                    r2 = r2 << numDefine6;
                    r4 = heapClassInst.heap32[r4 + numDefine15];
                    r2 = (r4 + r2) | 0;
                    heapClassInst.heap16[(r2 + numDefine48) >> 1] = (short) r3;
                    r1 = (r1 + 1) | 0;
                    r2 = heapClassInst.heapU16[(r0 + numDefine58) >> 1];
                    r3 = (r3 + 1) | 0;
                    r4 = r1 & numDefine65535;
                    if (!(uint(r2) > uint(r4))) {
                        break repeat5;
                    }
                }
            }
            r1 = r2 & numDefine65535;
            r0 = r0 >> numDefine2;
            r1 = r1 << numDefine6;
            r0 = heapClassInst.heap32[r0 + numDefine15];
            r0 = (r1 + r0) | 0;
            r1 = 0;
            heapClassInst.heap16[(r0 + numDefineNeg16) >> 1] = (short) r1;
        }

    }

    public static void zn20btAxisSweep3InternalItE10printStatsEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;

    }

    public static void zn20btAxisSweep3InternalItE8aabbTestERK9btVector3S3R24btBroadphaseAabbCallback(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine27];
        r3 = heapClassInst.heap32[fp + 1];
        r4 = heapClassInst.heap32[fp + numDefine2];
        r5 = heapClassInst.heap32[fp + numDefine3];
        if (r2 != 0) {
            r0 = r2 >> numDefine2;
            r0 = heapClassInst.heap32[r0];
            r0 = r0 >> numDefine2;
            r0 = heapClassInst.heap32[r0 + numDefine7];
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r3;
            heapClassInst.heap32[g0 + numDefine2] = r4;
            heapClassInst.heap32[g0 + numDefine3] = r5;
            functionTable.get(r0 >> numDefine2).accept(i7);

        } else {
            r2 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
            r2 = r2 << 1;
            r2 = r2 | 1;
            if (!(r2 == 1)) {
                r2 = 1;
                r6 = numDefine2;
                repeat6:
                while (true) {
                    r7 = r6;
                    r6 = r2 & numDefine65535;
                    r8 = heapClassInst.heap32[r1 + numDefine17];
                    r6 = r6 << numDefine2;
                    r9 = heapClassInst.heapU8[r8 + r6];
                    r9 = r9 & 1;
                    if (!(r9 == 0)) {
                        r6 = (r8 + r6) | 0;
                        r6 = heapClassInst.heapU16[(r6 + numDefine2) >> 1];
                        r8 = heapClassInst.heap32[r1 + numDefine15];
                        r6 = r6 << numDefine6;
                        r6 = (r8 + r6) | 0;
                        r8 = r3 >> numDefine2;
                        r9 = r6 >> numDefine2;
                        f0 = heapClassInst.heapFloat[r8];
                        f1 = heapClassInst.heapFloat[r9 + numDefine8];
                        if (f0 > f1) {
                            label = numDefine8;
                        } else {
                            r10 = r4 >> numDefine2;
                            f0 = heapClassInst.heapFloat[r10];
                            f1 = heapClassInst.heapFloat[r9 + numDefine4];
                            if (f0 < f1) {
                                label = numDefine8;
                            } else {
                                r10 = 1;
                                label = numDefine9;
                            }
                        }
                        if (label == numDefine8) {
                            r10 = 0;
                        }
                        f0 = heapClassInst.heapFloat[r8 + numDefine2];
                        f1 = heapClassInst.heapFloat[r9 + numDefine10];
                        if (f0 > f1) {
                            label = numDefine11;
                        } else {
                            r11 = r4 >> numDefine2;
                            f0 = heapClassInst.heapFloat[r11 + numDefine2];
                            f1 = heapClassInst.heapFloat[r9 + numDefine6];
                            if (f0 < f1) {
                                label = numDefine11;
                            } else {
                                label = numDefine12;
                            }
                        }
                        if (label == numDefine11) {
                            r10 = 0;
                        }
                        f0 = heapClassInst.heapFloat[r8 + 1];
                        f1 = heapClassInst.heapFloat[r9 + numDefine9];
                        if (!(f0 > f1)) {
                            r8 = r4 >> numDefine2;
                            f0 = heapClassInst.heapFloat[r8 + 1];
                            f1 = heapClassInst.heapFloat[r9 + numDefine5];
                            if (!(f0 < f1)) {
                                r8 = r10 & numDefine255;
                                if (!(r8 == 0)) {
                                    r8 = r5 >> numDefine2;
                                    r8 = heapClassInst.heap32[r8];
                                    r8 = r8 >> numDefine2;
                                    r8 = heapClassInst.heap32[r8 + numDefine2];
                                    heapClassInst.heap32[g0] = r5;
                                    heapClassInst.heap32[g0 + 1] = r6;
                                    functionTable.get(r8 >> numDefine2).accept(i7);
                                }
                            }
                        }
                    }
                    r8 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
                    r6 = (r7 + 1) | 0;
                    r2 = (r2 + 1) | 0;
                    r8 = r8 << 1;
                    r7 = r7 & numDefine65535;
                    r8 = r8 | 1;
                    if (!(uint(r7) < uint(r8))) {
                        break repeat6;
                    }
                }
            }

        }
    }

    public static void zn20btAxisSweep3InternalItE7rayTestERK9btVector3S3R23btBroadphaseRayCallbackS3S3(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine27];
        r3 = heapClassInst.heap32[fp + numDefine3];
        if (r2 != 0) {
            r0 = heapClassInst.heap32[fp + 1];
            r1 = heapClassInst.heap32[fp + numDefine2];
            r4 = heapClassInst.heap32[fp + numDefine4];
            r5 = heapClassInst.heap32[fp + numDefine5];
            r6 = r2 >> numDefine2;
            r6 = heapClassInst.heap32[r6];
            r6 = r6 >> numDefine2;
            r6 = heapClassInst.heap32[r6 + numDefine6];
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r0;
            heapClassInst.heap32[g0 + numDefine2] = r1;
            heapClassInst.heap32[g0 + numDefine3] = r3;
            heapClassInst.heap32[g0 + numDefine4] = r4;
            heapClassInst.heap32[g0 + numDefine5] = r5;
            functionTable.get(r6 >> numDefine2).accept(i7);

        } else {
            r2 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
            r2 = r2 << 1;
            r2 = r2 | 1;
            if (!(r2 == 1)) {
                r2 = 1;
                r4 = numDefine2;
                repeat6:
                while (true) {
                    r5 = r2 & numDefine65535;
                    r6 = heapClassInst.heap32[r1 + numDefine17];
                    r5 = r5 << numDefine2;
                    r7 = heapClassInst.heapU8[r6 + r5];
                    r7 = r7 & 1;
                    if (!(r7 == 0)) {
                        r7 = r3 >> numDefine2;
                        r7 = heapClassInst.heap32[r7];
                        r7 = r7 >> numDefine2;
                        r5 = (r6 + r5) | 0;
                        r5 = heapClassInst.heapU16[(r5 + numDefine2) >> 1];
                        r6 = heapClassInst.heap32[r7 + numDefine2];
                        r7 = heapClassInst.heap32[r1 + numDefine15];
                        r5 = r5 << numDefine6;
                        r5 = (r7 + r5) | 0;
                        heapClassInst.heap32[g0] = r3;
                        heapClassInst.heap32[g0 + 1] = r5;
                        functionTable.get(r6 >> numDefine2).accept(i7);
                    }
                    r5 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
                    r6 = (r4 + 1) | 0;
                    r2 = (r2 + 1) | 0;
                    r5 = r5 << 1;
                    r7 = r4 & numDefine65535;
                    r5 = r5 | 1;
                    r4 = r6;
                    if (!(uint(r7) < uint(r5))) {
                        break repeat6;
                    }
                }
            }

        }
    }

    public static void zn20btAxisSweep3InternalItE9sortMaxUpEitP12btDispatcherb(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp];
        r2 = r0 << numDefine2;
        r2 = (r1 + r2) | 0;
        r2 = r2 >> numDefine2;
        r3 = heapClassInst.heap32[fp + numDefine2];
        r4 = 1;
        r2 = heapClassInst.heap32[r2 + numDefine17];
        r3 = r3 << numDefine2;
        r2 = (r2 + r3) | 0;
        r3 = r4 << r0;
        r3 = r3 & numDefine3;
        r1 = r1 >> numDefine2;
        r5 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
        r4 = r4 << r3;
        r6 = heapClassInst.heap32[r1 + numDefine15];
        r5 = r5 << numDefine6;
        r4 = r4 & numDefine3;
        r5 = (r6 + r5) | 0;
        r3 = r3 << 1;
        r6 = (r5 + numDefine48) | 0;
        r4 = r4 << 1;
        r5 = (r5 + numDefine54) | 0;
        r0 = r0 << 1;
        r7 = heapClassInst.heap32[fp + numDefine3];
        r8 = (r5 + r3) | 0;
        r9 = (r6 + r3) | 0;
        r10 = (r5 + r4) | 0;
        r6 = (r6 + r4) | 0;
        r5 = (r5 + r0) | 0;
        r2 = (r2 + numDefine4) | 0;
        repeat1:
        while (true) {
            r11 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
            if (r11 == 0) {
                break repeat1;
            } else {
                r12 = heapClassInst.heapU16[r2 >> 1];
                r13 = heapClassInst.heapU16[(r2 + numDefineNeg4) >> 1];
                if (uint(r13) >= uint(r12)) {
                    r13 = heapClassInst.heap32[r1 + numDefine15];
                    r11 = r11 & numDefine65535;
                    r12 = r12 & 1;
                    if (r12 != 0) {
                        r11 = r11 << numDefine6;
                        r11 = (r13 + r11) | 0;
                        r11 = (r11 + r0) | 0;
                        r12 = heapClassInst.heapU16[(r11 + numDefine54) >> 1];
                        r12 = (r12 + -1) | 0;
                        heapClassInst.heap16[(r11 + numDefine54) >> 1] = (short) r12;
                    } else {
                        if (!(r7 == 0)) {
                            r12 = r11 << numDefine6;
                            r12 = (r13 + r12) | 0;
                            r14 = (r12 + r3) | 0;
                            r15 = heapClassInst.heapU16[r8 >> 1];
                            r16 = heapClassInst.heapU16[(r14 + numDefine48) >> 1];
                            if (!(uint(r15) < uint(r16))) {
                                r14 = heapClassInst.heapU16[(r14 + numDefine54) >> 1];
                                r15 = heapClassInst.heapU16[r9 >> 1];
                                if (!(uint(r14) < uint(r15))) {
                                    r14 = (r12 + r4) | 0;
                                    r15 = heapClassInst.heapU16[r10 >> 1];
                                    r16 = heapClassInst.heapU16[(r14 + numDefine48) >> 1];
                                    if (!(uint(r15) < uint(r16))) {
                                        r14 = heapClassInst.heapU16[(r14 + numDefine54) >> 1];
                                        r15 = heapClassInst.heapU16[r6 >> 1];
                                        if (!(uint(r14) < uint(r15))) {
                                            r14 = heapClassInst.heap32[r1 + numDefine23];
                                            r15 = r14 >> numDefine2;
                                            r15 = heapClassInst.heap32[r15];
                                            r15 = r15 >> numDefine2;
                                            r16 = heapClassInst.heapU16[(r2 + numDefineNeg2) >> 1];
                                            r15 = heapClassInst.heap32[r15 + numDefine2];
                                            r16 = r16 << numDefine6;
                                            r16 = (r13 + r16) | 0;
                                            heapClassInst.heap32[g0] = r14;
                                            heapClassInst.heap32[g0 + 1] = r16;
                                            heapClassInst.heap32[g0 + numDefine2] = r12;
                                            functionTable.get(r15 >> numDefine2).accept(i7);
                                            r14 = heapClassInst.heap32[r1 + numDefine24];
                                            if (!(r14 == 0)) {
                                                r15 = r14 >> numDefine2;
                                                r15 = heapClassInst.heap32[r15];
                                                r15 = r15 >> numDefine2;
                                                r15 = heapClassInst.heap32[r15 + numDefine2];
                                                heapClassInst.heap32[g0] = r14;
                                                heapClassInst.heap32[g0 + 1] = r16;
                                                heapClassInst.heap32[g0 + numDefine2] = r12;
                                                functionTable.get(r15 >> numDefine2).accept(i7);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        r11 = r11 << numDefine6;
                        r11 = (r13 + r11) | 0;
                        r11 = (r11 + r0) | 0;
                        r12 = heapClassInst.heapU16[(r11 + numDefine48) >> 1];
                        r12 = (r12 + -1) | 0;
                        heapClassInst.heap16[(r11 + numDefine48) >> 1] = (short) r12;
                    }
                    r11 = heapClassInst.heapU16[r5 >> 1];
                    r11 = (r11 + 1) | 0;
                    heapClassInst.heap16[r5 >> 1] = (short) r11;
                    r11 = heapClassInst.heapU16[(r2 + numDefineNeg2) >> 1];
                    r12 = heapClassInst.heapU16[(r2 + numDefineNeg4) >> 1];
                    r13 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
                    r14 = heapClassInst.heapU16[r2 >> 1];
                    heapClassInst.heap16[(r2 + numDefineNeg4) >> 1] = (short) r14;
                    heapClassInst.heap16[(r2 + numDefineNeg2) >> 1] = (short) r13;
                    r13 = (r2 + numDefine4) | 0;
                    heapClassInst.heap16[r2 >> 1] = (short) r12;
                    heapClassInst.heap16[(r2 + numDefine2) >> 1] = (short) r11;
                    r2 = r13;
                    continue repeat1;
                } else {
                    break repeat1;
                }
            }
        }
        return;
    }

    public static void zn20btAxisSweep3InternalItE9sortMinUpEitP12btDispatcherb(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp];
        r2 = r0 << numDefine2;
        r2 = (r1 + r2) | 0;
        r2 = r2 >> numDefine2;
        r3 = heapClassInst.heap32[fp + numDefine2];
        r2 = heapClassInst.heap32[r2 + numDefine17];
        r3 = r3 << numDefine2;
        r2 = (r2 + r3) | 0;
        r1 = r1 >> numDefine2;
        r3 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
        r4 = 1;
        r5 = r4 << r0;
        r6 = heapClassInst.heap32[r1 + numDefine15];
        r3 = r3 << numDefine6;
        r5 = r5 & numDefine3;
        r3 = (r6 + r3) | 0;
        r0 = r0 << 1;
        r3 = (r3 + r0) | 0;
        r4 = r4 << r5;
        r6 = heapClassInst.heap32[fp + numDefine3];
        r7 = heapClassInst.heap32[fp + numDefine4];
        r3 = (r3 + numDefine48) | 0;
        r4 = r4 & numDefine3;
        r2 = (r2 + numDefine4) | 0;
        repeat1:
        while (true) {
            r8 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
            if (r8 == 0) {
                break repeat1;
            } else {
                r9 = heapClassInst.heapU16[r2 >> 1];
                r10 = heapClassInst.heapU16[(r2 + numDefineNeg4) >> 1];
                if (uint(r10) >= uint(r9)) {
                    r10 = heapClassInst.heap32[r1 + numDefine15];
                    r8 = r8 & numDefine65535;
                    r9 = r9 & 1;
                    if (r9 == 0) {
                        r8 = r8 << numDefine6;
                        r8 = (r10 + r8) | 0;
                        r8 = (r8 + r0) | 0;
                        r9 = heapClassInst.heapU16[(r8 + numDefine48) >> 1];
                        r9 = (r9 + -1) | 0;
                        heapClassInst.heap16[(r8 + numDefine48) >> 1] = (short) r9;
                    } else {
                        if (!(r7 == 0)) {
                            r9 = heapClassInst.heapU16[(r2 + numDefineNeg2) >> 1];
                            r9 = r9 << numDefine6;
                            r11 = r8 << numDefine6;
                            r9 = (r10 + r9) | 0;
                            r12 = r5 << 1;
                            r11 = (r10 + r11) | 0;
                            r13 = (r9 + r12) | 0;
                            r12 = (r11 + r12) | 0;
                            r14 = heapClassInst.heapU16[(r13 + numDefine54) >> 1];
                            r15 = heapClassInst.heapU16[(r12 + numDefine48) >> 1];
                            if (!(uint(r14) < uint(r15))) {
                                r12 = heapClassInst.heapU16[(r12 + numDefine54) >> 1];
                                r13 = heapClassInst.heapU16[(r13 + numDefine48) >> 1];
                                if (!(uint(r12) < uint(r13))) {
                                    r12 = r4 << 1;
                                    r13 = (r9 + r12) | 0;
                                    r12 = (r11 + r12) | 0;
                                    r14 = heapClassInst.heapU16[(r13 + numDefine54) >> 1];
                                    r15 = heapClassInst.heapU16[(r12 + numDefine48) >> 1];
                                    if (!(uint(r14) < uint(r15))) {
                                        r12 = heapClassInst.heapU16[(r12 + numDefine54) >> 1];
                                        r13 = heapClassInst.heapU16[(r13 + numDefine48) >> 1];
                                        if (!(uint(r12) < uint(r13))) {
                                            r12 = heapClassInst.heap32[r1 + numDefine23];
                                            r13 = r12 >> numDefine2;
                                            r13 = heapClassInst.heap32[r13];
                                            r13 = r13 >> numDefine2;
                                            r13 = heapClassInst.heap32[r13 + numDefine3];
                                            heapClassInst.heap32[g0] = r12;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r11;
                                            heapClassInst.heap32[g0 + numDefine3] = r6;
                                            functionTable.get(r13 >> numDefine2).accept(i7);
                                            r12 = heapClassInst.heap32[r1 + numDefine24];
                                            if (!(r12 == 0)) {
                                                r13 = r12 >> numDefine2;
                                                r13 = heapClassInst.heap32[r13];
                                                r13 = r13 >> numDefine2;
                                                r13 = heapClassInst.heap32[r13 + numDefine3];
                                                heapClassInst.heap32[g0] = r12;
                                                heapClassInst.heap32[g0 + 1] = r9;
                                                heapClassInst.heap32[g0 + numDefine2] = r11;
                                                heapClassInst.heap32[g0 + numDefine3] = r6;
                                                functionTable.get(r13 >> numDefine2).accept(i7);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        r8 = r8 << numDefine6;
                        r8 = (r10 + r8) | 0;
                        r8 = (r8 + r0) | 0;
                        r9 = heapClassInst.heapU16[(r8 + numDefine54) >> 1];
                        r9 = (r9 + -1) | 0;
                        heapClassInst.heap16[(r8 + numDefine54) >> 1] = (short) r9;
                    }
                    r8 = heapClassInst.heapU16[r3 >> 1];
                    r8 = (r8 + 1) | 0;
                    heapClassInst.heap16[r3 >> 1] = (short) r8;
                    r8 = heapClassInst.heapU16[(r2 + numDefineNeg2) >> 1];
                    r9 = heapClassInst.heapU16[(r2 + numDefineNeg4) >> 1];
                    r10 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
                    r11 = heapClassInst.heapU16[r2 >> 1];
                    heapClassInst.heap16[(r2 + numDefineNeg4) >> 1] = (short) r11;
                    heapClassInst.heap16[(r2 + numDefineNeg2) >> 1] = (short) r10;
                    r10 = (r2 + numDefine4) | 0;
                    heapClassInst.heap16[r2 >> 1] = (short) r9;
                    heapClassInst.heap16[(r2 + numDefine2) >> 1] = (short) r8;
                    r2 = r10;
                    continue repeat1;
                } else {
                    break repeat1;
                }
            }
        }
        return;
    }

    public static void zn20btAxisSweep3InternalItE7setAabbEP17btBroadphaseProxyRK9btVector3S5P12btDispatcher(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg40;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine2];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = r0 >> numDefine2;
        r3 = r1 >> numDefine2;
        heapClassInst.heap32[r3 + numDefine4] = heapClassInst.heap32[r2];
        heapClassInst.heap32[r3 + numDefine5] = heapClassInst.heap32[r2 + 1];
        r4 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[r3 + numDefine6] = heapClassInst.heap32[r2 + numDefine6];
        heapClassInst.heap32[r3 + numDefine7] = heapClassInst.heap32[r2 + numDefine7];
        r5 = r4 >> numDefine2;
        heapClassInst.heap32[r3 + numDefine8] = heapClassInst.heap32[r5];
        heapClassInst.heap32[r3 + numDefine9] = heapClassInst.heap32[r5 + 1];
        r6 = heapClassInst.heap32[fp];
        heapClassInst.heap32[r3 + numDefine10] = heapClassInst.heap32[r5 + numDefine2];
        heapClassInst.heap32[r3 + numDefine11] = heapClassInst.heap32[r5 + numDefine3];
        r7 = r6 >> numDefine2;
        r1 = heapClassInst.heapU16[(r1 + numDefine12) >> 1];
        r8 = heapClassInst.heap32[r7 + numDefine15];
        f0 = heapClassInst.heapFloat[r2];
        f1 = heapClassInst.heapFloat[r2 + 1];
        f2 = heapClassInst.heapFloat[r2 + numDefine2];
        r2 = sp + numDefineNeg6;
        heapClassInst.heap32[g0] = r6;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heapFloat[g0 + numDefine2] = (float) f0;
        heapClassInst.heapFloat[g0 + numDefine3] = (float) f1;
        heapClassInst.heapFloat[g0 + numDefine4] = (float) f2;
        heapClassInst.heap32[g0 + numDefine5] = 0;
        znk20btAxisSweep3InternalItE8quantizeEPtRK9btVector3i(i7);
        f0 = heapClassInst.heapFloat[r5];
        f1 = heapClassInst.heapFloat[r5 + 1];
        f2 = heapClassInst.heapFloat[r5 + numDefine2];
        r1 = r1 << numDefine6;
        r5 = sp + numDefineNeg12;
        r1 = (r8 + r1) | 0;
        heapClassInst.heap32[g0] = r6;
        heapClassInst.heap32[g0 + 1] = r5;
        heapClassInst.heapFloat[g0 + numDefine2] = (float) f0;
        heapClassInst.heapFloat[g0 + numDefine3] = (float) f1;
        heapClassInst.heapFloat[g0 + numDefine4] = (float) f2;
        heapClassInst.heap32[g0 + numDefine5] = 1;
        r8 = heapClassInst.heap32[fp + numDefine4];
        r1 = (r1 + numDefine48) | 0;
        r9 = 0;
        znk20btAxisSweep3InternalItE8quantizeEPtRK9btVector3i(i7);
        r10 = r9;
        repeat1:
        while (true) {
            r11 = r9 << numDefine2;
            r12 = r9 << 1;
            r13 = (r1 - r12) | 0;
            r11 = (r6 - r11) | 0;
            r14 = heapClassInst.heapU16[r13 >> 1];
            r13 = heapClassInst.heapU16[(r13 + numDefine6) >> 1];
            r11 = r11 >> numDefine2;
            r15 = (r2 - r12) | 0;
            r12 = (r5 - r12) | 0;
            r16 = heapClassInst.heap32[r11 + numDefine17];
            r17 = r14 << numDefine2;
            r18 = r13 << numDefine2;
            r15 = heapClassInst.heapU16[r15 >> 1];
            r19 = heapClassInst.heapU16[(r16 + r17) >> 1];
            r20 = heapClassInst.heapU16[(r16 + r18) >> 1];
            r12 = heapClassInst.heapU16[r12 >> 1];
            heapClassInst.heap16[(r16 + r17) >> 1] = (short) r15;
            r11 = heapClassInst.heap32[r11 + numDefine17];
            r15 = (r15 - r19) | 0;
            heapClassInst.heap16[(r11 + r18) >> 1] = (short) r12;
            if (!(r15 > -1)) {
                heapClassInst.heap32[g0] = r6;
                heapClassInst.heap32[g0 + 1] = r10;
                heapClassInst.heap32[g0 + numDefine2] = r14;
                heapClassInst.heap32[g0 + numDefine3] = 1;
                zn20btAxisSweep3InternalItE11sortMinDownEitP12btDispatcherb(i7);
            }
            r11 = (r12 - r20) | 0;
            if (!(r11 < 1)) {
                heapClassInst.heap32[g0] = r6;
                heapClassInst.heap32[g0 + 1] = r10;
                heapClassInst.heap32[g0 + numDefine2] = r13;
                heapClassInst.heap32[g0 + numDefine3] = 1;
                zn20btAxisSweep3InternalItE9sortMaxUpEitP12btDispatcherb(i7);
            }
            if (!(r15 < 1)) {
                heapClassInst.heap32[g0] = r6;
                heapClassInst.heap32[g0 + 1] = r10;
                heapClassInst.heap32[g0 + numDefine2] = r14;
                heapClassInst.heap32[g0 + numDefine3] = r8;
                heapClassInst.heap32[g0 + numDefine4] = 1;
                zn20btAxisSweep3InternalItE9sortMinUpEitP12btDispatcherb(i7);
            }
            if (!(r11 > -1)) {
                heapClassInst.heap32[g0] = r6;
                heapClassInst.heap32[g0 + 1] = r10;
                heapClassInst.heap32[g0 + numDefine2] = r13;
                heapClassInst.heap32[g0 + numDefine3] = r8;
                heapClassInst.heap32[g0 + numDefine4] = 1;
                zn20btAxisSweep3InternalItE11sortMaxDownEitP12btDispatcherb(i7);
            }
            r9 = (r9 + -1) | 0;
            r10 = (r10 + 1) | 0;
            if (r9 != numDefineNeg3) {
                continue repeat1;
            } else {
                break repeat1;
            }
        }
        r1 = heapClassInst.heap32[r7 + numDefine27];
        if (!(r1 == 0)) {
            r2 = r1 >> numDefine2;
            r2 = heapClassInst.heap32[r2];
            r2 = r2 >> numDefine2;
            r2 = heapClassInst.heap32[r2 + numDefine4];
            r3 = heapClassInst.heap32[r3 + numDefine15];
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r3;
            heapClassInst.heap32[g0 + numDefine2] = r0;
            heapClassInst.heap32[g0 + numDefine3] = r4;
            heapClassInst.heap32[g0 + numDefine4] = r8;
            functionTable.get(r2 >> numDefine2).accept(i7);
        }

    }

    public static void zn20btAxisSweep3InternalItE12destroyProxyEP17btBroadphaseProxyP12btDispatcher(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine27];
        r3 = heapClassInst.heap32[fp + 1];
        r4 = heapClassInst.heap32[fp + numDefine2];
        if (!(r2 == 0)) {
            r5 = r2 >> numDefine2;
            r5 = heapClassInst.heap32[r5];
            r5 = r5 >> numDefine2;
            r6 = r3 >> numDefine2;
            r5 = heapClassInst.heap32[r5 + numDefine3];
            r6 = heapClassInst.heap32[r6 + numDefine15];
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r6;
            heapClassInst.heap32[g0 + numDefine2] = r4;
            functionTable.get(r5 >> numDefine2).accept(i7);
        }
        r2 = heapClassInst.heap32[r1 + numDefine23];
        r5 = r2 >> numDefine2;
        r5 = heapClassInst.heap32[r5];
        r5 = r5 >> numDefine2;
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine3];
        r6 = heapClassInst.heap32[r1 + numDefine15];
        r5 = heapClassInst.heap32[r5 + numDefine14];
        heapClassInst.heap32[g0] = r2;
        functionTable.get(r5 >> numDefine2).accept(i7);
        r2 = commonVariable.rg0;
        if (!(r2 != 0)) {
            r2 = heapClassInst.heap32[r1 + numDefine23];
            r5 = r2 >> numDefine2;
            r5 = heapClassInst.heap32[r5];
            r5 = r5 >> numDefine2;
            r5 = heapClassInst.heap32[r5 + numDefine4];
            r7 = r3 & numDefine65535;
            r7 = r7 << numDefine6;
            r7 = (r6 + r7) | 0;
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r7;
            heapClassInst.heap32[g0 + numDefine2] = r4;
            functionTable.get(r5 >> numDefine2).accept(i7);
        }
        r2 = heapClassInst.heap32[r1 + numDefine15];
        r5 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
        r7 = heapClassInst.heapU16[(r2 + numDefine54) >> 1];
        r7 = (r7 + numDefineNeg2) | 0;
        heapClassInst.heap16[(r2 + numDefine54) >> 1] = (short) r7;
        r2 = heapClassInst.heap32[r1 + numDefine15];
        r7 = heapClassInst.heapU16[(r2 + numDefine56) >> 1];
        r7 = (r7 + numDefineNeg2) | 0;
        r8 = r3 & numDefine65535;
        heapClassInst.heap16[(r2 + numDefine56) >> 1] = (short) r7;
        r2 = heapClassInst.heap32[r1 + numDefine15];
        r7 = r8 << numDefine6;
        r9 = heapClassInst.heapU16[(r2 + numDefine58) >> 1];
        r6 = (r6 + r7) | 0;
        r5 = r5 << 1;
        r6 = (r6 + numDefine54) | 0;
        r10 = 0;
        r9 = (r9 + numDefineNeg2) | 0;
        heapClassInst.heap16[(r2 + numDefine58) >> 1] = (short) r9;
        r2 = r10;
        repeat7:
        while (true) {
            r9 = r2 << numDefine2;
            r9 = (r0 + r9) | 0;
            r9 = r9 >> numDefine2;
            r11 = heapClassInst.heapU16[r6 >> 1];
            r12 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
            r9 = heapClassInst.heap32[r9 + numDefine17];
            r13 = r11 << numDefine2;
            heapClassInst.heap16[(r9 + r13) >> 1] = (short) r12;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r2;
            heapClassInst.heap32[g0 + numDefine2] = r11;
            heapClassInst.heap32[g0 + numDefine3] = 0;
            zn20btAxisSweep3InternalItE9sortMaxUpEitP12btDispatcherb(i7);
            r11 = heapClassInst.heapU16[(r6 + numDefineNeg6) >> 1];
            r12 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
            r13 = r11 << numDefine2;
            heapClassInst.heap16[(r9 + r13) >> 1] = (short) r12;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r2;
            heapClassInst.heap32[g0 + numDefine2] = r11;
            heapClassInst.heap32[g0 + numDefine3] = r4;
            heapClassInst.heap32[g0 + numDefine4] = 0;
            r11 = r5 << numDefine2;
            zn20btAxisSweep3InternalItE9sortMinUpEitP12btDispatcherb(i7);
            r9 = (r9 + r11) | 0;
            heapClassInst.heap16[(r9 + numDefineNeg2) >> 1] = (short) r10;
            r11 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
            r2 = (r2 + 1) | 0;
            r6 = (r6 + numDefine2) | 0;
            heapClassInst.heap16[(r9 + numDefineNeg4) >> 1] = (short) r11;
            if (r2 != numDefine3) {
                continue repeat7;
            } else {
                break repeat7;
            }
        }
        if (!(r8 == 0)) {
            r2 = heapClassInst.heapU16[(r0 + numDefine58) >> 1];
            if (uint(r2) > uint(r8)) {
                r1 = heapClassInst.heap32[r1 + numDefine15];
                r2 = heapClassInst.heapU16[(r0 + numDefine64) >> 1];
                r1 = (r1 + r7) | 0;
                heapClassInst.heap16[(r1 + numDefine48) >> 1] = (short) r2;
                heapClassInst.heap16[(r0 + numDefine64) >> 1] = (short) r3;
                r1 = heapClassInst.heapU16[(r0 + numDefine56) >> 1];
                r1 = (r1 + -1) | 0;
                heapClassInst.heap16[(r0 + numDefine56) >> 1] = (short) r1;

            }
        }
        r0 = twoEStr11;
        r1 = twoEStr112;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = numDefine495;
        assertNew(i7);

    }

}


